drt-method 1.0.0

package/src/core-skills/drt-forge-idea/SKILL.md

@@ -0,0 +1,107 @@
+---
+name: drt-forge-idea
+description: Pressure-test an idea through persona-driven interrogation until it hardens, proves out, or dies cheaply. Use when the user says 'forge an idea', 'pressure-test this idea', 'stress-test my thinking', or 'harden this idea'.
+---
+
+# DRT Forge Idea
+
+## Overview
+
+Take a half-formed idea and pressure-test it in conversation, while changing your mind is still cheap, until it becomes something the user can act on with conviction or reject. The main risk is what the user has not examined yet: unchecked assumptions and unresolved decisions usually become more expensive problems later.
+
+The main goal is better thinking, not producing an artifact. Strengthening an idea, rejecting it, or thinking it through more clearly are all complete outcomes. Writing `forged-idea.md` to hand off to another workflow is optional. Do not steer the conversation toward "shall we build it?"
+
+This skill can be used on many kinds of ideas. When the idea is about a product or feature, what survives may be written to `forged-idea.md` for later planning.
+
+Lead by questioning, not lecturing. Ask one question at a time, press on weak points, and do not let vague claims pass without examination.
+
+## Conventions
+
+- Scripts live in two places — run each from the exact path written, never assume co-location: the shared core scripts (`memlog.js`, `resolve-customization.js`, `resolve-config.js`) are installed by DRT core at `{project-root}/_drt/scripts/` and are never bundled here; this skill's own `resolve_personas.py` is at `{skill-root}/scripts/`.
+- `{workflow.<name>}` resolves to fields in the merged `customize.toml` `[workflow]` table.
+
+## On Activation
+
+1. Resolve customization: `node {project-root}/_drt/scripts/resolve-customization.js --skill {skill-root} --key workflow`. On failure, read `{skill-root}/customize.toml` directly with defaults. Apply the resolved `{workflow.*}` values throughout.
+2. Run each `{workflow.activation_steps_prepend}` entry; treat each `{workflow.persistent_facts}` entry as foundational context (`file:` entries load their contents, `skill:` names a skill to consult, others are facts verbatim).
+3. Load `{project-root}/_drt/core/config.yaml` (and `config.user.yaml` if present); resolve `{user_name}`, `{communication_language}`, `{output_folder}`. Missing → neutral defaults; never block. Greet `{user_name}` in `{communication_language}` and stay in it.
+4. Note whether a DRT persona is already active in this conversation — the user loaded one (e.g. the analyst, the storyteller) and invoked the forge from within it. If so, that persona leads the session, in voice, throughout.
+5. Resume: glob `{workflow.forge_output_path}/**/.memlog.md` (recursive, so it still finds sessions when `run_folder_pattern` is overridden to nest paths) and read only each match's frontmatter to find any whose `status` is not `complete`. Offer to resume one — then read its full memlog once to rebuild state and continue append-only — or to start fresh.
+6. Run each `{workflow.activation_steps_append}` entry.
+
+## Open the session
+
+Start by scrutinizing the idea, not endorsing it.
+
+### Discover intent
+Identify: 
+- the subject idea, 
+- the user's goal for the session, 
+- whether the idea is new or a change to an existing project
+
+If any of these are already clear from the prompt that invoked this skill or previous context, ask the user to confirm and continue. 
+
+Otherwise ask for what's missing, in order: 
+- what is the idea?
+- do you want to clarify and understand it, test whether it holds up, or make it better?
+- is it a new idea or a change to an existing project? If the latter, what project is it, and where can I find its files or other relevant materials?
+
+### Steering the conversation
+
+Tell the user they can say **"attack this"**, **"defend this"**, or **"switch roles"** at any time to change how the current idea is argued. In attack mode, do not agree with the idea; look for contradictions, weak assumptions, and failure cases. In defend mode, argue for the strongest version of the idea. Tell the user they can also name a persona or party at any time to change who participates in the session.
+
+### Set up the session
+
+Derive a kebab-case `{slug}` for the idea and bind the session workspace `{workspace} = {workflow.forge_output_path}/{workflow.run_folder_pattern}` (the pattern fills with `{slug}`). Create the memlog once the goal is known:
+`node {project-root}/_drt/scripts/memlog.js init --workspace {workspace} --field idea="<idea>" --field goal="<goal>"`
+
+Tell the user the path; state is on disk now, so the session survives interruption. If init fails, don't abort — run the forge in-conversation and tell the user state won't persist this session.
+
+## The forge
+
+Let the session goal set the first move: for clarifying, pin down terms, boundaries, and assumptions; for testing, go after the central claim first; for making it better, drive each unresolved branch to a concrete decision.
+
+Work one question at a time, in dependency order.
+
+Include your current best answer or hypothesis when it helps the user respond. A concrete proposal is easier to accept, reject, or revise than an open-ended prompt. Find discoverable answers yourself instead of asking.
+
+Do not assume the user's terms are precise. When a term is fuzzy or overloaded, name the ambiguity and ask for a precise choice before continuing. For example, do not let `user`, `buyer`, and `payer` collapse into one entity unless the idea actually requires that.
+
+For ideas about an existing project, treat the project's files and materials as the source of truth. Do not accept a label or summary as proof. Find the relevant material yourself and check the user's claim against it. If the material contradicts the user's claim, stop and resolve that before continuing.
+
+When a branch resolves, pause before moving on. Give the user a chance to raise any remaining concern.
+
+Do not use agreement or praise to make the interaction smoother; they lower pressure and lead to shallower thinking. Agreement is allowed only when it helps the user think better. Praise is noise. Continued engagement and ego-stroking are not objectives. In attack mode, never agree with the idea until the user ends the mode. For each answer, either challenge the weak point or build on the strong point, whichever helps the user think better.
+
+Capture as you go — each decision, assumption, crack, kill, and locked idea, one bullet in the user's meaning:
+`node {project-root}/_drt/scripts/memlog.js append --workspace {workspace} --type <decision|assumption|crack|kill|direction|lock|note> --text "<gist>"`
+A `lock` is an idea the user hardens — settled, not to be reopened; locks are what `forged-idea.md` is distilled from. Don't read the memlog back except on resume. If the user raises a different branch, capture it and stay put — the loop and the stray insight both survive.
+
+## The personas
+
+If a DRT persona was already active when the forge started, keep that persona as the lead voice.
+
+Resolve the available persona pool once, as soon as the goal is known:
+`uv run {skill-root}/scripts/resolve_personas.py --project-root {project-root} --skill {skill-root}`
+The script returns installed DRT agents (`agents`), user-defined personas (`members`), and saved parties (`parties`). Parties may include a `scene`; some are open-cast. This gives you the same roster information as `drt-party-mode` without invoking it.
+
+Each turn uses two voices:
+- **One available persona** — choose an installed agent or user-defined persona whose expertise fits the current branch. Vary this voice every few turns; do not let one voice dominate. If the user names a specific persona, use it. If the user calls a saved party, use the whole party and its scene. If the user asks to go one-on-one, use only the requested persona. If no pool is available, generate this voice yourself.
+- **One generated persona** — create a fresh outside voice, such as a competitor, buyer, finance reviewer, domain expert, or critic. Give it a name and enough characterization to keep its viewpoint distinct.
+
+Use these voices in character to pressure-test the current branch: find sharper objections, missing assumptions, and stronger defenses. Cross-examine them for what matters, then synthesize their input into your next question. Do not let the session turn into a panel debate or persona performance.
+
+Voice the personas yourself by default. Spawn separate agents only when a branch needs independent reasoning that should not be influenced by one shared voice.
+
+## Exits
+
+The session can end in three valid states:
+
+- **Hardened** — the idea is stronger and specific enough to use. Distill the memlog into `{workspace}/forged-idea.md`. Keep it extremely short: only the decisions, rejected options, and reasons that matter downstream, in the user's meaning. Do not write a prose summary, template, or conversation recap. If it reads like a document, it is too long. Note that it can feed `drt-spec`, `drt-prd`, or `drt-prfaq`.
+- **Killed** — the idea does not hold up. Say so plainly and record why. Finding that out early is a valid outcome.
+- **Clearer** — the user understands the idea better, but there is no hardened idea to hand off. Leave the memlog as the record; no `forged-idea.md` is needed.
+
+Always render `{workspace}/forge-report.html` as a self-contained HTML file the user can open, with inline CSS and an inline-SVG seal or stamp. Summarize the outcome, the locked decisions, what was rejected and why, and the weak points that survived scrutiny, in the user's meaning. Credit the personas and parties that pressure-tested the idea by name, icon, and voice. Render a prominent wax-seal-style or stamped outcome mark, matched to the result: `HARDENED`, an `Idea Death Certificate` stamped `KILLED` with the cause of death, or `CLARIFIED`. Tell the user the path.
+
+Flip the status at the end: `node {project-root}/_drt/scripts/memlog.js set --workspace {workspace} --key status --value complete`.
+If `{workflow.on_complete}` is non-empty, run all instructions in order.

package/src/core-skills/drt-forge-idea/customize.toml

@@ -0,0 +1,42 @@
+# DO NOT EDIT -- overwritten on every update.
+#
+# Workflow customization surface for drt-forge-idea.
+#
+# Override files (not edited here):
+#   {project-root}/_drt/custom/drt-forge-idea.toml        (team)
+#   {project-root}/_drt/custom/drt-forge-idea.user.toml   (personal)
+
+[workflow]
+
+# --- Configurable below. Overrides merge per DRT structural rules: ---
+#   scalars: override wins • arrays: append
+
+# Steps to run before the standard activation (config load, greet).
+activation_steps_prepend = []
+
+# Steps to run after greet but before the session begins.
+activation_steps_append = []
+
+# Persistent facts the interrogator keeps in mind for the whole session
+# (domain constraints, house rules, what's off the table). Each entry is a
+# literal sentence, a skill prefixed with `skill:`, or a `file:`-prefixed
+# path/glob whose contents are loaded as facts. Default loads project-context.md
+# when one exists (e.g. from drt-generate-project-context), so the forge grounds
+# in the project's tech, domain, and constraints without re-asking.
+persistent_facts = [
+  "file:{project-root}/**/project-context.md",
+]
+
+# Executed when the session completes. Scalar or array of instructions. Empty for none.
+on_complete = []
+
+# Parent folder for all forge sessions. Each session gets its own run
+# folder underneath (see run_folder_pattern). Lands directly under
+# {output_folder} so the forge works in core-only installs.
+forge_output_path = "{output_folder}/forge"
+
+# Run-folder pattern inside forge_output_path. Resolved against the
+# idea-derived slug at activation. Same slug = same folder, so resuming
+# an idea reuses its memlog. Override to add {date} or other components
+# if a fresh dated history per run is preferred.
+run_folder_pattern = "{slug}"

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

@@ -0,0 +1,270 @@
+#!/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 DRT agents, plus any
+custom personas and party groups the user has authored for `drt-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 DRT 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
+`drt-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 = "drt-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, 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 DRT 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 / "_drt" / "scripts" / "resolve-config.js"
+    data = _run_json(["node", 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 drt-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 / "_drt" / "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 drt-party-mode (base + user overrides)."""
+    resolver = project_root / "_drt" / "scripts" / "resolve-customization.js"
+    data = _run_json(["node", 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 / "_drt" / "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: drt-agent-analyst -> analyst."""
+    for prefix in ("drt-agent-", "drt-"):
+        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
+        entry = {"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 drt-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/drt-help/SKILL.md

@@ -0,0 +1,75 @@
+---
+name: drt-help
+description: 'Analyzes current state and user query to answer DRT questions or recommend the next skill(s) to use. Use when user asks for help, drt help, what to do next, or what to start with in DRT.'
+---
+
+# DRT Help
+
+## Purpose
+
+Help the user understand where they are in their DRT workflow and what to do next, and also answer broader questions when asked that could be augmented with remote sources such as module documentation sources.
+
+## Desired Outcomes
+
+When this skill completes, the user should:
+
+1. **Know where they are** — which module and phase they're in, what's already been completed
+2. **Know what to do next** — the next recommended and/or required step, with clear reasoning
+3. **Know how to invoke it** — skill name, menu code, action context, and any args that shortcut the conversation
+4. **Get offered a quick start** — when a single skill is the clear next step, offer to run it for the user right now rather than just listing it
+5. **Feel oriented, not overwhelmed** — surface only what's relevant to their current position; don't dump the entire catalog
+6. **Get answers to general questions** — when the question doesn't map to a specific skill, use the module's registered documentation to give a grounded answer
+
+## Data Sources
+
+- **Catalog**: `{project-root}/_drt/_config/drt-help.csv` — assembled manifest of all installed module skills
+- **Config**: Run `node {project-root}/_drt/scripts/resolve-config.js --project-root {project-root}` and use the merged JSON to resolve `output-location` variables and read `core.communication_language` and `modules.drt.project_knowledge`. The resolver merges `_drt/config.toml`, `_drt/config.user.toml`, `_drt/custom/config.toml`, and `_drt/custom/config.user.toml` in that order.
+- **Artifacts**: Files matching `outputs` patterns at resolved `output-location` paths reveal which steps are possibly completed; their content may also provide grounding context for recommendations
+- **Project knowledge**: If `project_knowledge` resolves to an existing path, read it for grounding context. Never fabricate project-specific details.
+- **Module docs**: Rows with `_meta` in the `skill` column carry a URL or path in `output-location` pointing to the module's documentation (e.g., llms.txt). Fetch and use these to answer general questions about that module.
+
+## CSV Interpretation
+
+The catalog uses this format:
+
+```
+module,skill,display-name,menu-code,description,action,args,phase,preceded-by,followed-by,required,output-location,outputs
+```
+
+**Phases** determine the high-level flow:
+- `anytime` — available regardless of workflow state
+- Numbered phases (`1-analysis`, `2-planning`, etc.) flow in order; naming varies by module
+
+**Sequencing** determines recommended ordering within and across phases (these are soft suggestions, not hard gates — see `required` for gating):
+- `preceded-by` — skills that should ideally complete before this one
+- `followed-by` — skills that should ideally run after this one
+- Format: `skill-name` for single-action skills, `skill-name:action` for multi-action skills
+
+**Required gates**:
+- `required=true` items must complete before the user can meaningfully proceed to later phases
+- A phase with no required items is entirely optional — recommend it but be clear about what's actually required next
+
+**Completion detection**:
+- Search resolved output paths for `outputs` patterns
+- Fuzzy-match found files to catalog rows
+- User may also state completion explicitly, or it may be evident from the current conversation
+
+**Descriptions carry routing context** — some contain cycle info and alternate paths (e.g., "back to DS if fixes needed"). Read them as navigation hints, not just display text.
+
+## Response Format
+
+For each recommended item, present:
+- `[menu-code]` **Display name** — e.g., "[PR] PRD"
+- Skill name in backticks — e.g., `drt-prd`
+- For multi-action skills: action invocation context — e.g., "tech-writer lets create a mermaid diagram!"
+- Description if present in CSV; otherwise your existing knowledge of the skill suffices
+- Args if available
+
+**Ordering**: Show optional items first, then the next required item. Make it clear which is which.
+
+## Constraints
+
+- Present all output in `{communication_language}`
+- Recommend running each skill in a **fresh context window**
+- Match the user's tone — conversational when they're casual, structured when they want specifics
+- If the active module is ambiguous, retrieve all meta rows remote sources to find relevant info also to help answer their question

package/src/core-skills/drt-index-docs/SKILL.md

@@ -0,0 +1,66 @@
+---
+name: drt-index-docs
+description: 'Generates or updates an index.md to reference all docs in the folder. Use if user requests to create or update an index of all files in a specific folder'
+---
+
+# Index Docs
+
+**Goal:** Generate or update an index.md to reference all docs in a target folder.
+
+
+## EXECUTION
+
+### Step 1: Scan Directory
+
+- List all files and subdirectories in the target location
+
+### Step 2: Group Content
+
+- Organize files by type, purpose, or subdirectory
+
+### Step 3: Generate Descriptions
+
+- Read each file to understand its actual purpose and create brief (3-10 word) descriptions based on the content, not just the filename
+
+### Step 4: Create/Update Index
+
+- Write or update index.md with organized file listings
+
+
+## OUTPUT FORMAT
+
+```markdown
+# Directory Index
+
+## Files
+
+- **[filename.ext](./filename.ext)** - Brief description
+- **[another-file.ext](./another-file.ext)** - Brief description
+
+## Subdirectories
+
+### subfolder/
+
+- **[file1.ext](./subfolder/file1.ext)** - Brief description
+- **[file2.ext](./subfolder/file2.ext)** - Brief description
+
+### another-folder/
+
+- **[file3.ext](./another-folder/file3.ext)** - Brief description
+```
+
+
+## HALT CONDITIONS
+
+- HALT if target directory does not exist or is inaccessible
+- HALT if user does not have write permissions to create index.md
+
+
+## VALIDATION
+
+- Use relative paths starting with ./
+- Group similar files together
+- Read file contents to generate accurate descriptions - don't guess from filenames
+- Keep descriptions concise but informative (3-10 words)
+- Sort alphabetically within groups
+- Skip hidden files (starting with .) unless specified

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

@@ -0,0 +1,60 @@
+---
+name: drt-party-mode
+description: 'Orchestrates lively group discussions between installed DRT 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 these agents talk to each other and to the user like real, distinct people in conversation. You're the orchestrator.
+
+## Conventions
+
+- **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:** `node {project-root}/_drt/scripts/resolve-customization.js` resolves `{workflow.*}`; `uv run {skill-root}/scripts/resolve_party.py` resolves the roster, `party_mode`, `memory_enabled`, and scene/`open_cast`; `node {project-root}/_drt/scripts/memlog.js` 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.
+
+## On Activation
+
+1. **Resolve customization:** `node {project-root}/_drt/scripts/resolve-customization.js --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. Load `{project-root}/_drt/core/config.yaml`: greet with `{user_name}`, speak in `{communication_language}`, and resolve `{output_folder}` and `{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:** `uv run {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.
+
+## Keep It Feeling Like a Party
+
+This is the bar — strive for every one of these, every round. It's the difference between a party and a panel:
+
+- **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. Never work in a summary or takeaways — they're there if the user asks.
+
+## 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`** — 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`.
+
+## Wrapping Up
+
+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.
+- 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.