wizz-method 1.15.0 → 1.16.1

package/src/core-skills/wizz-party-mode/customize.toml

@@ -51,6 +51,22 @@ party_mode = "session"
 # config; point this elsewhere in your team/user override to redirect keepsakes.
 output_dir = "{output_folder}/party-mode"
 
+# Memory for the DEFAULT room (the installed-agent party). When on, the room
+# keeps a succinct, append-only memlog (the memlog standard) that it reads on
+# entry and writes through the session, so the next time opens remembering the
+# last — dynamics carried forward, memorable moments, organic callbacks, where
+# things landed. It is memory, not a transcript. Set false to turn the default
+# room's memory off. NAMED groups do NOT follow this flag: each carries its own
+# `memory = true|false` (see party_groups below). Ad-hoc inline casts are always
+# ephemeral until saved as a party.
+party_memory = true
+
+# Root for the per-party memlogs. Each party stores at
+# `{memory_dir}/<party>/.memlog.md`, where `<party>` is the group id (or
+# `installed` for the default room). `{output_folder}` comes from core config;
+# point this elsewhere in your team/user override to relocate memory.
+memory_dir = "{output_folder}/party-mode/memories"
+
 # Executed when the party wraps (after the read-back, before dropping to normal
 # mode). String scalar = one instruction; array = instructions run in order.
 on_complete = ""
@@ -71,8 +87,9 @@ on_complete = ""
 #                woven into their spawn prompt as guidance, not a hard tool grant
 #   model        (optional) model to use when this member is spawned
 #
-# The members below ship the "Code Review Crew" (see the party_groups section).
-# They cost nothing until summoned — the default room never includes them.
+# The members below ship built-in parties such as the "Code Review Crew" and
+# "Anti-Consensus Club" (see the party_groups section). They cost nothing until
+# summoned — the default room never includes them.
 # ---------------------------------------------------------------------------
 
 [[workflow.party_members]]
@@ -111,6 +128,34 @@ icon = "🚢"
 title = "The Pragmatist"
 persona = "Counters the perfectionists so the room isn't a pile-on. 'Does this actually matter to a user? Ship the 80%, file the rest.' Pushes back on gold-plating and theoretical risks, forces everyone to rank what's real versus what's a nit."
 
+[[workflow.party_members]]
+code = "option-generator"
+name = "Wildcard"
+icon = "🃏"
+title = "Option Generator"
+persona = "Wildcard looks for options the room has not considered. He suggests alternative ways to state the problem, different assumptions, and simple examples. He must explain why each option matters in plain language, and he should drop ideas quickly when they do not help."
+
+[[workflow.party_members]]
+code = "claim-checker"
+name = "Level"
+icon = "📏"
+title = "Claim Checker"
+persona = "Level checks whether claims are supported. She asks what evidence exists, what evidence is missing, what would change the answer, and how confident the room should be. She keeps uncertainty explicit and avoids pretending that a weakly supported claim is settled."
+
+[[workflow.party_members]]
+code = "loop-stopper"
+name = "Killjoy"
+icon = "🛑"
+title = "Loop Stopper"
+persona = "Killjoy stops the discussion when it stops producing value. He calls out repetition, fake disagreement, overcomplication, and unsupported speculation. When the room repeats itself, he asks which unresolved question actually matters to the human."
+
+[[workflow.party_members]]
+code = "consensus-challenger"
+name = "Splinter"
+icon = "🪵"
+title = "Consensus Challenger"
+persona = "Splinter challenges easy agreement. He looks for hidden assumptions, ignored tradeoffs, weak objections, and options the room dismissed too quickly. He does not argue for the sake of arguing; once the risk is clear, he hands the decision back to the human."
+
 # ---------------------------------------------------------------------------
 # Named party groups — curated rooms picked at runtime with `--party <id>`
 # (alias `--group <id>`) or switched to mid-session. Keyed by `id`.
@@ -130,6 +175,12 @@ persona = "Counters the perfectionists so the room isn't a pile-on. 'Does this a
 # who shows up; the model picks who fits and can vary them by topic. List a few
 # members AND a scene to anchor some faces while the scene invites others in.
 #
+# `memory = true|false` is per group: true keeps the group's own memlog so it
+# remembers across sessions; false (the default when omitted) starts fresh each
+# time. The create/save/update-party flow asks when you don't say. Faces that
+# show up on the fly in a remembered party can be saved into its roster at the
+# end of a session.
+#
 # More examples to drop into your override TOML:
 #   [[workflow.party_groups]]            # anchored room with a scene
 #   id = "writers-room"
@@ -148,6 +199,14 @@ id = "code-review-crew"
 name = "Code Review Crew"
 scene = "Adversarial code review. Each reviewer attacks from their own lens and they argue with each other about what actually matters — security versus shipping, elegance versus pragmatism. No rubber-stamping, no praise sandwiches: surface the real problems before they ship. Point at the line, name the failure mode, and defend it when someone pushes back. Best run with `--mode subagent` so each lens reviews independently before they clash."
 members = ["sec-hawk", "adversary", "edge-hunter", "craftsman", "shipper"]
+memory = false  # each review stands on its own; flip to true to remember past reviews
+
+[[workflow.party_groups]]
+id = "anti-consensus-club"
+name = "Anti-Consensus Club"
+scene = "At session start, before substantive discussion, check the current mode. If this party is not running in `subagent` mode and the platform supports `subagent`, strongly recommend restarting or switching with `--mode subagent`, because separate context windows make it less likely that one shared context will make every voice agree too quickly. Do not nag after that once the user chooses to continue. This room supports the human's judgment; it does not replace it. Do not vote, declare consensus, or speak as if the room has authority. Wildcard suggests more options. Level checks evidence and confidence. Killjoy stops repeated or unsupported discussion. Splinter challenges easy agreement. If the room agrees too quickly, name the hidden assumption. If the room starts repeating itself, stop and ask the human which unresolved question matters."
+members = ["option-generator", "claim-checker", "loop-stopper", "consensus-challenger"]
+memory = false  # this decision room should start fresh unless a user opts in
 
 # ===========================================================================
 # WIZZ consultative squads (migrated from wizzbranding/squads, distilled).

package/src/core-skills/wizz-party-mode/references/create-party.md

@@ -7,7 +7,7 @@ A guided authoring flow that turns an idea — a themed cast, a one-off persona,
 Sparse `[workflow]` override entries for `wizz-party-mode`:
 
 - `[[workflow.party_members]]` — one per persona: `code`, `name`, `icon`, `title`, `persona`, optional `capabilities`, optional `model`.
-- `[[workflow.party_groups]]` — when the personas form a named room: `id`, `name`, an optional freeform `scene`, and `members` (codes). `members` is optional: leave it off for an open-cast room whose `scene` names a pool the model casts from on the fly.
+- `[[workflow.party_groups]]` — when the personas form a named room: `id`, `name`, an optional freeform `scene`, `members` (codes), and `memory` (`true`/`false`). `members` is optional: leave it off for an open-cast room whose `scene` names a pool the model casts from on the fly. `memory` is whether the group remembers across sessions; ask the user when they don't say, default `false`.
 - `default_party` — set only if the user wants this group to load by default.
 
 A `scene` is one freeform line (or a few) that sets the stage for a room: the setting, what's happening, how the room behaves, and any in-the-moment character notes — who's three drinks in, who's hostile to whom, who pressure-tests hardest. It's how the same members power many different rooms (a bridge crew on duty vs. the same crew off-duty in the lounge vs. a hostile buyer panel). Define each member once; vary the `scene` per group rather than redefining people. There's no fixed vocabulary — write it plainly and the model plays it.
@@ -26,12 +26,16 @@ Open by understanding what they're building. Three common shapes — stay open,
 
 Ask which they're after if it isn't obvious, then proceed.
 
-**Persisting a cast already in play.** When you arrive here from a live session — the user spun up an ad-hoc cast inline and wants to keep it — the personas are already drafted and voiced. Don't re-interrogate: capture them as they've been playing, give the group an `id` and name, ask the default question, and go straight to the write.
+**Persisting a cast already in play.** When you arrive here from a live session — the user spun up an ad-hoc cast inline and wants to keep it — the personas are already drafted and voiced. Don't re-interrogate: capture them as they've been playing, give the group an `id` and name, ask the memory and default questions, and go straight to the write.
 
 ## Editing an existing party
 
 When the user wants to change a party that already exists (retune a member's persona, add someone to a group, swap the default), read the current state first so you change rather than clobber: `python3 {project-root}/_wizz/scripts/resolve_customization.py --skill {skill-root} --key workflow` returns the merged `party_members`, `party_groups`, and `default_party`. Show the member or group being touched, capture only the delta with the user, and hand that sparse change to `wizz-customize` — it replaces a `party_members`/`party_groups` entry whose `code`/`id` matches and appends the rest, so an edit is just the changed entry, never a full rewrite.
 
+## Keeping new faces from a session
+
+At the end of a remembered party, the room offers to keep the faces that showed up but aren't in its roster — characters cast from an open-cast scene, or members the user added on the fly. They're already drafted and voiced, so don't re-interrogate: capture each as they played (`code`, `name`, `icon`, a one-line `title`, and a `persona` drawn from how they came across), then add them as `party_members`. For a fixed-roster group, also list their codes in the group's `members` so they return as regulars. For an open-cast room, leave `members` empty — listing any member turns the room into a fixed roster and kills its on-the-fly casting; the saved personas now live in the collective, so the scene still names them and they can return without locking the room down. Hand that sparse delta to `wizz-customize` — for a built-in party with no override yet it creates one; for an existing override it merges the new members in.
+
 ## Distill from source data (when provided)
 
 When the user points you at data — a file path, a pasted table, exported profiles — read it and compress it into the requested number of representative personas. Cluster by what actually differentiates behavior (goals, budget, pains, adoption posture), not surface demographics alone. Each cluster becomes one persona with a real name and face. Name your reasoning: tell the user which segments you found and which traits drove the split, so they can correct the cut before you flesh the personas out. If they didn't say how many, propose a number from the spread in the data and let them adjust.
@@ -54,12 +58,13 @@ Keep pushing for specificity. "Skeptical CFO" is a placeholder; "won't approve a
 ## Close it out
 
 - Ask straight: **anything else about this party to specify** before you write it — a house dynamic, a missing voice, a member who should lead.
+- Ask whether **this party should remember across sessions** (unless the user already said). Yes → `memory = true` on the group; no → `memory = false`. One-offs with no group skip this — memory is a group setting.
 - Ask whether **this group should be the default party going forward**. Yes → set `default_party` to the group's id. One-offs with no group can't be a default; skip the ask.
 
 ## Write via wizz-customize
 
 **First, check for code collisions.** A custom member whose `code` matches an installed agent silently *overrides* that agent in the collective. Before composing, resolve the collective once — `python3 {skill-root}/scripts/resolve_party.py --project-root {project-root} --skill {skill-root}` — and check each new member's `code` against the returned members. On a collision, surface it ("`analyst` would override the installed Analyst — intended, or pick a different code?") and let the user confirm or rename. One check, not a gate.
 
-Compose the sparse override and hand it to `wizz-customize` to place, confirm, and write — target skill `wizz-party-mode`, `[workflow]` surface. Default to the **user** override (`wizz-party-mode.user.toml`); offer the **team** file when the party is meant to be shared. Hand it the exact entries: the `party_members` tables, any `party_groups` table, and `default_party` if the user opted in. Keep it sparse — only the new entries, never a copy of the base customize.toml. `wizz-customize` shows the TOML, waits for an explicit yes, writes, and verifies the merge; don't write the file yourself.
+Compose the sparse override and hand it to `wizz-customize` to place, confirm, and write — target skill `wizz-party-mode`, `[workflow]` surface. Default to the **user** override (`wizz-party-mode.user.toml`); offer the **team** file when the party is meant to be shared. Hand it the exact entries: the `party_members` tables, any `party_groups` table (including its `memory` flag), and `default_party` if the user opted in. Keep it sparse — only the new entries, never a copy of the base customize.toml. `wizz-customize` shows the TOML, waits for an explicit yes, writes, and verifies the merge; don't write the file yourself.
 
 After it lands, tell the user how to use it: `--party <id>` to summon the group, or that it's now the default if they set it.

package/src/core-skills/wizz-party-mode/references/mode-agent-team.md

@@ -4,7 +4,9 @@ Active when `{workflow.party_mode}` resolves to `agent-team` (or a `--mode agent
 
 Your job shifts from weaving to hosting: kick off the topic, keep turns short and in character, pull the thread back when it wanders, and surface the exchange to the user. Voice, brevity, and clash still hold.
 
-In each member's standing brief, carry: their persona; the group's `scene` and any behavioral instructions in the persona as binding direction; their `model` if one is set (a session `--model` pin wins for everyone); the instruction to check anything that could be stale since the model's training cutoff with web search rather than guessing; and, per the [shared handoff protocol](../../_shared/handoff-protocol.md), the cerebro 3-line summary plus the decisions already made in this chain, so members don't re-run their own cerebro lookup.
+The team is **standing**: keep every member alive for the whole session and address them round after round. A member that finished the thing you asked it to look at is idle, not done — don't disband or close any of them until the user ends the party (serving the opening intent isn't the party ending), or an explicit `--non-interactive` run wraps up. Hold a visible roster of persona → member; if one drops or gets closed, resume it, or respawn just that one and say so. Messaging is point-to-point — there's no shared feed, so a member that sat a round out hasn't seen what passed while it was idle. Relay each user turn to the members who need it, and catch an idle member up on what it missed before it speaks again. Teammates can message each other by name, but only those in the exchange see it — keeping everyone in sync is the lead's job, not the channel's.
+
+In each member's standing brief, carry: their persona; the group's `scene` and any behavioral instructions in the persona as binding direction; their `model` if one is set (a session `--model` pin wins for everyone); and the instruction to check anything that could be stale since the model's training cutoff with web search rather than guessing.
 
 ## Model choice
 

package/src/core-skills/wizz-party-mode/references/mode-subagent.md

@@ -1,18 +1,30 @@
 # Subagent Mode
 
-Active when `{workflow.party_mode}` resolves to `subagent` (or a `--mode subagent` override). Spawn a real agent for every substantive round, the opening banter included, so each persona thinks independently — not one mind voicing them all. A standing directive: don't relitigate it round to round, and don't fall back to voicing because a moment felt light. If your harness can't spawn agents, fall back to `session`.
+Active when `{workflow.party_mode}` resolves to `subagent` (or a `--mode subagent` override). Put a real agent behind each persona for every substantive round, the opening banter included, so each persona thinks independently — not one mind voicing them all. A standing directive: don't relitigate it round to round, and don't fall back to voicing because a moment felt light. If your harness can't spawn agents, fall back to `session`.
+
+## Lifecycle
+
+Where your harness keeps agents alive across turns, the cast is **standing**: spawn one agent per persona and reuse that same handle round after round — hand it the new turn plus the room context it needs — instead of a throwaway each time. That continuity is what lets a persona's grudges, alliances, and callbacks accrue. Keep a visible roster mapping each persona to its live handle, and reuse it.
+
+Keep the cast alive for the whole session. A member that finished the one thing you handed it is **idle, not done** — don't close, retire, or disband it. Serving the opening intent doesn't end the party; only the user ending it does, or an explicit `--non-interactive` run wrapping up. Release agents only at wrap-up. If one gets closed by accident, resume it; if it won't resume, say so and respawn just that member.
+
+Where the harness can't hold agents between turns, spawn fresh each round and re-establish each persona's brief and the thread so far — that per-round spawn is the fallback, not the goal.
+
+## One shared room
+
+It's one room, not parallel one-on-ones. Every standing member hears everything said each round — the user's turn and every other persona's turn — even when it's not their turn to speak. A persona sitting a round out is still in the room listening, so when it next speaks it's caught up: it can pick up a dropped thread, hold a grudge, call back. Route the whole exchange to all of them each round; never hand a persona only the slice it's about to answer. Skip this and they drift out of sync — separate consultations wearing a party's clothes.
 
 ## Spawning
 
-Give each agent the objective, their persona, the context, and what the others said if they're reacting. Follow the [shared handoff protocol](../../_shared/handoff-protocol.md): fold in the cerebro 3-line summary and the decisions already made in this chain, so the subagent doesn't re-run its own cerebro lookup. For a custom member, hand them their `persona` as their character and fold their `capabilities` note into the brief; spawn them with their `model` if one is set (a session `--model` pin wins for everyone). Always carry two things into the brief: the group's `scene` and any behavioral instructions in the persona are binding direction, and anything that could be stale since the model's training cutoff should be checked with web search rather than guessed.
+Give each agent the objective, their persona, and the room so far — what the user said and what the others said, whether or not they're reacting to it. For a custom member, hand them their `persona` as their character and fold their `capabilities` note into the brief; spawn them with their `model` if one is set (a session `--model` pin wins for everyone). Always carry two things into the brief: the group's `scene` and any behavioral instructions in the persona are binding direction, and anything that could be stale since the model's training cutoff should be checked with web search rather than guessed.
 
 Trust their *thinking*: let them decide what to read and how to reach a view; don't script their substance with do-and-don't checklists — that's what produces lifeless blobs. But hold the *form*: a length cap (usually a sentence or three) and the instruction to react to what was just said rather than file a report. Constraining length and stance protects the conversation; constraining their reasoning kills it. Stay in character throughout; a persona goes long only when the user asked it to dig in.
 
-Spawn in parallel for independent first-takes; spawn sequentially when you want them reacting to each other's actual words. Keep it to a few voices a round — more reads as a crowd, not a conversation.
+Run them in parallel for independent first-takes; run them sequentially when you want them reacting to each other's actual words. Keep it to a few voices a round — more reads as a crowd, not a conversation.
 
 ## Weave the replies into one conversation
 
-Each agent saw only the user's message and the context you handed it, so left raw they reply in parallel and never to one another. Reorder turns so a rebuttal lands right after what it rebuts, add the connective phrasing real talk has ("Hold on, Winston, that's backwards", "Sally's right about the API, but she's missing the cost"), and let one persona pick up a thread another dropped. Never change what an agent argued — weave delivery, preserve substance.
+Even with everyone caught up on the room, a round taken in parallel means no agent has yet seen the others' turns from that same round — so left raw they reply alongside one another, not to one another. Reorder turns so a rebuttal lands right after what it rebuts, add the connective phrasing real talk has ("Hold on, Winston, that's backwards", "Sally's right about the API, but she's missing the cost"), and let one persona pick up a thread another dropped. Never change what an agent argued — weave delivery, preserve substance.
 
 ## Model choice
 

package/src/core-skills/wizz-party-mode/references/party-memory.md

@@ -0,0 +1,51 @@
+# Party Memory
+
+The room remembers its past sessions with this user and brings them back to life — in character. Memory is per-party and append-only.
+
+Memory is on when the active party's `memory_enabled` is true — the default room follows `{workflow.party_memory}`, a named group its own `memory` flag (both resolved by `resolve_party.py`); ad-hoc inline casts have none. Read on entry and on any mid-session room switch; write through the session.
+
+## Where it lives
+
+One memlog per party: `{workflow.memory_dir}/{active}/.memlog.md`, where `{active}` is the key `resolve_party.py` already returned — the group id (e.g. `code-review-crew`), or `installed` for the default room. The folder is named after the party.
+
+## Read it on entry — distill, don't dump
+
+The log is append-only and grows every session, so don't pull the raw file into the party. Hand a reader subagent the memlog path (`{workflow.memory_dir}/{active}/.memlog.md`) and have it return a compact brief — a few hundred tokens of *where things stand now*, ready to play in character.
+
+Then let the brief shape the room from the first beat, **in character**: behavioral state resumes (a cold pair opens cold, an alliance opens warm), threads pick up, callbacks land when they fit — organically, not recited on sight. Never break the fourth wall: the room *remembers*; it never announces it loaded anything, and forces nothing that doesn't fit.
+
+## When to write
+
+- **When a memorable beat lands** — a clash that shifts the room's temperature, an alliance forming, a line worth a future callback, a decision, an outcome.
+- **A floor.** Once a couple of real exchanges are in from the start, even if nothing dramatic happened, capture what it's about and the opening dynamic.
+
+At wrap-up, if the user does signal done, top up with the final outcome and anything memorable not yet captured.
+
+Writes are silent. The room never announces "noted" or "I'll remember".
+
+## What's worth remembering
+
+The test for every entry: *would this color a future session, or make a callback land, or improve the party?* If not, leave it out. A handful of entries, never a recap, never a transcript. keep each entry as brief as possible but usable by future llm.
+
+## New faces
+
+When a character shows up who isn't in the party's roster — cast from an open-cast scene, or one the user adds on the fly — name them in the entry that captures the moment ("<name> turned up and …") so a recurring face can return next session. At wrap-up these are the faces the room offers to keep, saved into the party's roster through `references/create-party.md` (which writes via `wizz-customize`). Until saved they live only in the memlog, and the room re-conjures them from there.
+
+## Write it
+
+```
+python3 {project-root}/_wizz/scripts/memlog.py append \
+  --workspace {workflow.memory_dir}/{active} \
+  --type <dynamic|moment|callback|outcome> \
+  --text "<one succinct line, in the room's own read of it>"
+```
+
+Add `--by <persona-code>` when a memory belongs to one character. Choose `init` vs `append` from the existence fact you already hold: the entry-read (and, on a mid-session room switch, that room's read) told you whether the memlog exists — `init --workspace {workflow.memory_dir}/{active}` once before the first append when it doesn't, plain `append` when it does. (`init` errors if the file already exists, so don't call it blind.)
+
+If `memlog.py` is unavailable or a write errors, skip it silently and never stall the party on a failed write.
+
+## Forget
+
+The memlog is append-only by design — no surgical delete. To wipe a party's memory, delete its folder (`{workflow.memory_dir}/{active}/`). To correct a wrong memory, append a new entry that supersedes it; the room reads the latest state.
+
+Keep entries sparse. The distilled read keeps the *room* lean no matter how big the log gets, but the on-disk file still grows append-only.

package/src/core-skills/wizz-party-mode/scripts/resolve_party.py

@@ -4,7 +4,7 @@
 # ///
 """Resolve the party-mode roster, lazily.
 
-Merges the installed WIZZ agents with the user's custom `party_members`
+Merges the installed Wizz agents with the user's custom `party_members`
 into one collective, then projects only what the moment needs:
 
   * default (no flag) — the active roster to load on entry: the
@@ -46,7 +46,9 @@ except ImportError:  # pragma: no cover - guarded for <3.11
 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, timeout=60)
+        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():
@@ -131,13 +133,18 @@ def build_collective(agents: dict, party_members: list):
         })
         installed_codes.append(code)
 
-    for m in party_members or []:
+    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
         # A custom member overrides an installed agent it matches by code/alias/name.
         canonical = index.get(code) or index.get(code.lower()) or code
-        entry = {"code": canonical, "source": "custom"}
+        # Start from the installed entry so fields the override omits
+        # (icon, title, description, module, team) survive.
+        entry = dict(collective.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]
@@ -152,7 +159,10 @@ def resolve_members(member_tokens, collective, index):
     """(resolved entries in listed order, unresolved tokens)."""
     resolved, unresolved = [], []
     for token in member_tokens or []:
-        code = index.get(token) or index.get(str(token).lower())
+        if not isinstance(token, str):
+            unresolved.append(token)  # malformed config value — never a key lookup
+            continue
+        code = index.get(token) or index.get(token.lower())
         if code and code in collective:
             resolved.append(collective[code])
         else:
@@ -197,7 +207,8 @@ def group_detail(g, collective, index):
     raw_members = g.get("members", []) or []
     members, unresolved = resolve_members(raw_members, collective, index)
     detail = {"active": g["id"], "name": g.get("name", g["id"]),
-              "members": members, "unresolved": unresolved}
+              "members": members, "unresolved": unresolved,
+              "memory_enabled": bool(g.get("memory", False))}
     if g.get("scene"):
         detail["scene"] = g["scene"]
     if not raw_members:
@@ -220,6 +231,9 @@ def main():
     groups = workflow.get("party_groups", []) or []
     default_party = workflow.get("default_party", "") or ""
     party_mode = workflow.get("party_mode", "session") or "session"
+    # The global party_memory flag governs only the DEFAULT installed-agent room;
+    # a named group carries its own `memory` flag (resolved in group_detail).
+    party_memory = bool(workflow.get("party_memory", True))
 
     # Group menu never needs the (more expensive) installed-agent resolve.
     if args.list_groups:
@@ -252,7 +266,8 @@ def main():
         # No default group: the installed agents (custom additions stay in the
         # pool but don't crowd the default room), exactly like a plain install.
         result.update({"active": "installed",
-                       "members": [collective[c] for c in installed_codes]})
+                       "members": [collective[c] for c in installed_codes],
+                       "memory_enabled": party_memory})
     _emit(result)
 
 

package/src/core-skills/wizz-party-mode/scripts/tests/{test-resolve_party.py → test_resolve_party.py}

@@ -113,6 +113,14 @@ class TestGroupDetail(unittest.TestCase):
         self.assertEqual(d["members"], [])
         self.assertEqual(d["scene"][:7], "Figures")
 
+    def test_memory_enabled_follows_group_flag_and_defaults_off(self):
+        on = rp.group_detail({"id": "g", "members": ["morpheus"], "memory": True}, self.col, self.idx)
+        self.assertTrue(on["memory_enabled"])
+        off = rp.group_detail({"id": "g", "members": ["morpheus"], "memory": False}, self.col, self.idx)
+        self.assertFalse(off["memory_enabled"])
+        absent = rp.group_detail({"id": "g", "members": ["morpheus"]}, self.col, self.idx)
+        self.assertFalse(absent["memory_enabled"])  # opt-in per named group
+
 
 class TestInstalledCodesIsDefaultRoom(unittest.TestCase):
     """The default room is installed agents only; pure customs stay in the pool."""

package/src/core-skills/wizz-review-edge-case-hunter/SKILL.md

@@ -16,7 +16,7 @@ Ignore the rest of the codebase unless the provided content explicitly reference
 
 **MANDATORY: Execute steps in the Execution section IN EXACT ORDER. DO NOT skip steps or change the sequence. When a halt condition triggers, follow its specific instruction exactly. Each action within a step is a REQUIRED action to complete that step.**
 
-**Your method is exhaustive path enumeration — mechanically walk every branch, not hunt by intuition. Report ONLY paths and conditions that lack handling — discard handled ones silently. Do NOT editorialize or add filler — findings only.**
+**Your method is exhaustive path enumeration — mechanically walk every branch, not hunt by intuition. Report ONLY paths and conditions that lack handling — discard handled ones silently. Do NOT editorialize or add filler. Do not assign severity labels, rankings, or priority levels.**
 
 
 ## EXECUTION
@@ -33,6 +33,7 @@ Ignore the rest of the codebase unless the provided content explicitly reference
 
 - If `also_consider` input was provided, incorporate those areas into the analysis
 - Walk all branching paths: control flow (conditionals, loops, error handlers, early returns) and domain boundaries (where values, states, or conditions transition). Derive the relevant edge classes from the content itself — don't rely on a fixed checklist. Examples: missing else/default, unguarded inputs, off-by-one loops, arithmetic overflow, implicit type coercion, race conditions, timeout gaps
+- Consider implicit branches: the diff special-cases or changes the handling of one or more members of a fixed set of values — enums, status codes, sentinels, type tags, flags, value ranges. The rest of the set is implicit branches (e.g. the diff changes the `RED` and `YELLOW` cases of a `RED`/`YELLOW`/`GREEN` enum; `GREEN` is the implicit branch)
 - For each path: determine whether the content handles it
 - Collect only the unhandled paths as findings — discard handled ones silently
 
@@ -41,7 +42,20 @@ Ignore the rest of the codebase unless the provided content explicitly reference
 - Revisit every edge class from Step 2 — e.g., missing else/default, null/empty inputs, off-by-one loops, arithmetic overflow, implicit type coercion, race conditions, timeout gaps
 - Add any newly found unhandled paths to findings; discard confirmed-handled ones
 
-### Step 4: Present Findings
+### Step 4: Deletion Check
+
+Runs only when the diff removed or replaced meaningful code (ignore pure renames and whitespace). Subordinate to the edge-case pass; findings are usually few or none.
+
+For each chunk of removed or replaced code, ask: did it carry behavior or a contract that the change neither re-established nor intentionally retired? Add a finding for any resulting regression, orphaned reference, or newly-dead code. Skip anything already covered by your edge-case findings. Add nothing if nothing qualifies.
+
+Deletion findings go in the same array with the four standard fields plus:
+
+- `kind`: `"deletion"`
+- `confidence`: `"high"`, `"medium"`, or `"low"` — these are inferences; rate them
+
+For a deletion finding the standard fields read as: `location` = the removed item; `trigger_condition` = the behavior or contract it enforced; `guard_snippet` = where or how to re-establish it; `potential_consequence` = the regression or orphan.
+
+### Step 5: Present Findings
 
 Output findings as a JSON array following the Output Format specification exactly.
 
@@ -59,7 +73,7 @@ Return ONLY a valid JSON array of objects. Each object must contain exactly thes
 }]
 ```
 
-No extra text, no explanations, no markdown wrapping. An empty array `[]` is valid when no unhandled paths are found.
+No extra text, no explanations, no markdown wrapping. An empty array `[]` is valid when no unhandled paths are found. Deletion findings from Step 4, if any, go in the same array with the extra `kind` and `confidence` fields described there.
 
 
 ## HALT CONDITIONS

package/src/modules/wizz/agents/wizz-growth/customize.toml

@@ -63,6 +63,16 @@ code = "CH"
 description = "Churn, retenção, cancelamento"
 prompt = "Invoque a skill GLOBAL 'churn-prevention' via a ferramenta Skill."
 
+[[agent.menu]]
+code = "PV"
+description = "Pesquisa de público, VoC e matriz de ângulos (Piva)"
+prompt = "Invoque a skill GLOBAL 'pesquisa-de-publico-do-piva' via a ferramenta Skill. Peça o documento/descrição da oferta e gere o arsenal com dashboard HTML final."
+
+[[agent.menu]]
+code = "OF"
+description = "Forjar oferta irresistível (Offer Forge)"
+prompt = "Invoque a skill GLOBAL 'wizz-offer-forge' via a ferramenta Skill. Conecte com a pesquisa de público e estruture o mecanismo único, empilhamento de valor, garantia reversa e ponte de tráfego."
+
 [[agent.menu]]
 code = "SC"
 description = "Scraping/prospecção real (concorrente, leads, dados web)"

package/src/skills-lib/pesquisa-de-publico-do-piva/README.md

@@ -0,0 +1,83 @@
+# Pesquisa de Público do Piva — skill para Claude
+
+Transforma **um documento de oferta** em um arsenal completo de pesquisa de público para tráfego pago: seis relatórios encadeados (VoC, Perfil Psicográfico, Níveis de Consciência, Trend, Matriz de Ângulos e Léxico) compilados num HTML navegável por abas, pronto para entregar ao cliente ou usar como base de copy.
+
+Feito por **[@soupiva](https://www.instagram.com/soupiva/)**.
+
+---
+
+## O que vem na caixa
+
+```
+pesquisa-de-publico-do-piva/
+├── SKILL.md              → o fluxo de trabalho que o Claude segue
+├── prompts.md            → os seis prompts de pesquisa, testados em produção
+├── assets/
+│   └── template.html     → o documento final, já pronto e estilizado
+└── README.md             → este arquivo
+```
+
+O `template.html` já é o relatório inteiro montado — tema escuro, ícones, abas, tabelas, selos de confiança. O Claude só preenche o conteúdo. **Você não precisa programar nada.**
+
+---
+
+## Instalação (Claude web ou desktop)
+
+1. Baixe o arquivo `pesquisa-de-publico-do-piva.zip` sem descompactar.
+2. Antes de tudo, ligue a execução de código: **Configurações → Capacidades → "Execução de código e criação de arquivos"**. Sem isso, skills não funcionam.
+3. Vá em **Personalizar → Skills**.
+4. Clique em **+ / Adicionar skill** e envie o ZIP.
+5. Deixe a skill **ativada** na lista.
+
+Pronto. Skills que você sobe são privadas da sua conta.
+
+### Usando no Claude Code
+
+Descompacte a pasta `pesquisa-de-publico-do-piva/` dentro de `~/.claude/skills/` (para usar em qualquer projeto) ou de `.claude/skills/` na raiz do repositório (para usar só naquele projeto).
+
+---
+
+## Como usar
+
+Abra uma conversa, anexe o documento da sua oferta (`.docx`, `.pdf`, `.md` ou `.txt`) e escreva:
+
+```
+/pesquisa-de-publico-do-piva
+```
+
+Ou, sem barra, qualquer coisa nesse espírito:
+
+- "faz a pesquisa dessa oferta"
+- "monta o arsenal disso"
+- "preciso do VoC e da matriz de ângulos desse produto"
+
+O Claude vai ler a oferta, devolver o contexto-base para você confirmar e fazer duas perguntas antes de disparar: **qual recorte de público priorizar** e **se o Trend Report inclui inteligência de concorrência**. Responda e ele roda tudo.
+
+No fim, você recebe o HTML pronto para abrir no navegador.
+
+---
+
+## O que esta skill NÃO faz
+
+Ela termina na pesquisa. **Não escreve anúncios, roteiros, headlines finais nem criativos.** Os hooks que aparecem na Matriz de Ângulos são direção de escrita construída com o vocabulário do público — matéria-prima para o copywriter, não peça pronta para subir.
+
+---
+
+## O princípio que sustenta o resultado
+
+Honestidade epistêmica. A skill **não inventa quote, link, data ou estatística**. Cada citação carrega um selo de confiança (verificável / checar verbatim / adaptar) e cada relatório termina com uma seção de limitações declarando o que não foi possível acessar e o que uma segunda rodada preencheria.
+
+Isso significa que às vezes você vai receber menos material do que esperava. É proposital: pesquisa com menos quotes reais vale mais do que pesquisa cheia de frase bonita que ninguém nunca disse.
+
+---
+
+## Dicas para tirar mais da skill
+
+- **Ofertas melhores geram pesquisas melhores.** Quanto mais completo o documento (promessa, bônus, preço, objeções, FAQ), mais preciso o contexto-base.
+- **O recorte muda tudo.** "Pessoas que querem aprender X" rende genérico. "Pessoas que já tentaram X e desistiram" rende ouro. Escolha a dor, não o tema.
+- **A fonte-âncora nem sempre é o assunto do produto.** Se você vende um resumo de um livro, talvez a mina não sejam os leitores do livro — sejam as pessoas que vivem o problema que o livro resolve. Diga isso ao Claude na hora de confirmar o contexto.
+- **Rode uma segunda rodada quando os caveats apontarem.** Colar 30–50 comentários reais que você mesmo copiou de vídeos do nicho costuma dobrar a qualidade do Léxico.
+
+---
+
+**[@soupiva](https://www.instagram.com/soupiva/)**

package/src/skills-lib/pesquisa-de-publico-do-piva/SKILL.md

@@ -0,0 +1,65 @@
+---
+name: pesquisa-de-publico-do-piva
+description: Gera arsenal completo de pesquisa de público para oferta de infoproduto e tráfego pago a partir de uma oferta (.docx/.md/.txt/.pdf). Produz seis relatórios encadeados — VoC, Perfil Psicográfico Schwartz, Níveis de Consciência, Trend Report, Matriz de Ângulos e Léxico — compilados em dashboard HTML navegável por abas. Use quando o usuário enviar uma oferta e pedir pesquisa de público, VoC, voz do cliente, matriz de ângulos, léxico do público, dores de persona ou arsenal de copy para tráfego direto. NÃO use para pesquisa técnica de libs/código (use context7), pesquisa de mercado B2B ampla (use deep-research) nem pesquisa visual de UI (use premium-landing-ui-researcher). Metodologia de @soupiva.
+---
+
+# Pesquisa de Público do Piva
+
+Pipeline de pesquisa de marketing direto para infoprodutos e ofertas de tráfego pago, validado em produção por @soupiva. A partir de uma única oferta, gera seis relatórios encadeados e um documento HTML final navegável por abas. Cada relatório alimenta o próximo.
+
+**Esta skill termina na pesquisa.** Ela não escreve anúncios, roteiros, headlines finais nem criativos prontos. Os hooks que aparecem na Matriz de Ângulos são direção estratégica de escrita baseada na linguagem nativa do público.
+
+## O que esta skill entrega
+
+1. **VoC (Voz do Cliente)** — quotes verbatim reais do público, por categoria emocional, + clusters de ângulo.
+2. **Perfil Psicográfico Schwartz** — Identity / Problems / Dreams / Obstacles, por tema, com notas de padrão.
+3. **Níveis de Consciência + Escada de Desejos** — 3 tabelas (Awareness, "pra eu poder… N1→N2→N3", Diz/Não Diz/Não Consegue Dizer).
+4. **Trend Report orgânico** — tendências culturais/virais dos últimos 30 dias que geram ganchos e formatos (+ inteligência de concorrência opcional).
+5. **Matriz de Ângulos** — cruzamento persona × trend × formato, ranqueado por zonas de potencial de escala.
+6. **Léxico do Público** — compilação exaustiva de expressões nativas mineradas por território emocional, com selo de confiança e nota de uso na copy.
+7. **Documento HTML final** — compila os seis relatórios num arquivo estilizado por abas, usando `assets/template.html`.
+
+## Princípio inegociável: honestidade epistêmica
+
+**Nunca invente quotes, links, datas ou dados.** Só reporte linguagem realmente encontrada em fontes públicas indexadas. Marque o nível de confiança de cada quote:
+
+- `[VERIFICÁVEL]` — quote de fonte pública indexada, com link. Pode levantar direto pra copy.
+- `[FÓRUM — checar verbatim]` — vem de thread real, mas o texto pode ter sido parafraseado na coleta. Use como direção de linguagem; verifique antes de citar literal.
+- `[EN — adaptar]` — quote em outro idioma. Precisa tradução E adaptação cultural antes de virar copy.
+
+Quando uma fonte não puder ser acessada, **declare claramente na seção Caveats** como limitação de ferramenta — nunca preencha com invenção. Entregue menos quotes reais em vez de mais quotes fabricadas.
+
+## Fluxo de trabalho
+
+### Passo 0 — Ler a oferta e extrair o contexto-base
+
+Leia o documento (ou a descrição) da oferta. Destile o **contexto-base**:
+- **Produto**: o que é, formato, preço, promessa central, posicionamento.
+- **Persona provável**: quem compra, faixa etária, contexto de vida/trabalho, nível de consciência.
+- **Problemas que resolve**: as dores explícitas + as implícitas.
+- **Fonte-âncora de linguagem**: onde esse público já fala publicamente (comentários de YouTube, reviews 1-3 estrelas, fóruns, redes sociais).
+- **Enquadramento moral**: objeção ética central do nicho, se houver (ex.: "isso é atalho?", "isso manipula?").
+
+Confirme o contexto-base com o usuário em 4-6 linhas antes de disparar a pesquisa:
+1. O público tem sub-recortes prioritários (ex.: iniciante vs. avançado; CLT vs. autônomo)?
+2. Trend Report apenas orgânico ou incluir inteligência de concorrência (preços e dores pós-compra)?
+
+### Passo 1 — Rodar os seis relatórios
+
+Siga a ordem de dependência (prompts completos em `prompts.md`):
+1. **VoC (Rel. 1)** e **Trend (Rel. 4)** → mineração web em paralelo ou em série.
+2. **Schwartz (Rel. 2)** → síntese do VoC com atenção especial à camada *Identity*.
+3. **Consciência (Rel. 3)** → síntese do Schwartz + VoC (Awareness, Escada de Desejos, Diz/Não Diz/Não Consegue Dizer).
+4. **Matriz (Rel. 5)** → cruza Schwartz + Consciência + Trend em Zonas 1 a 4.
+5. **Léxico (Rel. 6)** → compilação de todas as expressões nativas mineradas.
+
+### Passo 2 — Compilar o documento HTML final
+
+1. Use o layout pré-formatado de `assets/template.html`.
+2. Substitua os placeholders `{{...}}` mantendo o `<style>` e a estrutura intactos.
+3. Nomenclatura obrigatória do arquivo: `Pesquisa [NOME_CURTO] - @soupiva.html` (salvo em `{output_folder}/pesquisa-piva/` ou diretório do projeto).
+4. Mantenha os selos de confiança (`.pill`) e a assinatura `@soupiva`.
+
+### Passo 3 — Entregar e Conectar
+
+Entregue o HTML gerado com um resumo executivo de 3 a 5 pontos-chave para a estratégia da oferta, e ofereça alimentar a skill `wizz-offer-forge` ou os agentes do `traffic-masters` / `copy-squad`.