claude-code-workflow 7.2.15 → 7.2.16

package/.codex/skills/team-ultra-analyze/roles/coordinator/commands/monitor.md

@@ -0,0 +1,327 @@
+# Command: Monitor
+
+Handle all coordinator monitoring events: status checks, pipeline advancement, discussion loop control, and completion. Uses spawn_agent + wait_agent for synchronous coordination.
+
+## Constants
+
+| Key | Value |
+|-----|-------|
+| WORKER_AGENT | team_worker |
+| MAX_DISCUSSION_ROUNDS_QUICK | 0 |
+| MAX_DISCUSSION_ROUNDS_STANDARD | 1 |
+| MAX_DISCUSSION_ROUNDS_DEEP | 5 |
+
+## Phase 2: Context Loading
+
+| Input | Source | Required |
+|-------|--------|----------|
+| Session state | tasks.json | Yes |
+| Trigger event | From Entry Router detection | Yes |
+| Pipeline mode | From tasks.json `pipeline_mode` | Yes |
+| Discussion round | From tasks.json `discussion_round` | Yes |
+
+1. Load tasks.json for current state, `pipeline_mode`, `discussion_round`
+2. Read tasks from tasks.json to get current task statuses
+3. Identify trigger event type from Entry Router
+4. Compute max discussion rounds from pipeline mode:
+
+```
+MAX_ROUNDS = pipeline_mode === 'deep' ? 5
+           : pipeline_mode === 'standard' ? 1
+           : 0
+```
+
+## Phase 3: Event Handlers
+
+### handleCallback
+
+Triggered when a worker completes (wait_agent returns).
+
+1. Determine role from completed task prefix, then resolve completed tasks:
+
+   **Role detection** (from task prefix):
+
+   | Task Prefix | Role |
+   |-------------|------|
+   | `EXPLORE-*` | explorer |
+   | `ANALYZE-*` | analyst |
+   | `DISCUSS-*` | discussant |
+   | `SYNTH-*` | synthesizer |
+
+2. Mark task completed in tasks.json:
+
+```
+state.tasks[taskId].status = 'completed'
+```
+
+3. Record completion in session state via team_msg
+
+4. **Role-specific post-completion logic**:
+
+| Completed Role | Pipeline Mode | Post-Completion Action |
+|---------------|---------------|------------------------|
+| explorer | all | Log: exploration ready. Proceed to handleSpawnNext |
+| analyst | all | Log: analysis ready. Proceed to handleSpawnNext |
+| discussant | all | **Discussion feedback gate** (see below) |
+| synthesizer | all | Proceed to handleComplete |
+
+5. **Discussion Feedback Gate** (when discussant completes):
+
+When a DISCUSS-* task completes, the coordinator collects user feedback BEFORE spawning the next task.
+
+```
+// Read current discussion_round from tasks.json
+discussion_round = state.discussion_round || 0
+discussion_round++
+
+// Update tasks.json
+state.discussion_round = discussion_round
+
+// Check if discussion loop applies
+IF pipeline_mode === 'quick':
+    // No discussion in quick mode -- proceed to handleSpawnNext (SYNTH)
+    -> handleSpawnNext
+
+ELSE IF discussion_round >= MAX_ROUNDS:
+    // Reached max rounds -- force proceed to synthesis
+    Log: "Max discussion rounds reached, proceeding to synthesis"
+    IF no SYNTH-001 task exists in tasks.json:
+        Create SYNTH-001 task in tasks.json with deps on last DISCUSS task
+    -> handleSpawnNext
+
+ELSE:
+    // Collect user feedback
+    request_user_input({
+      questions: [{
+        question: "Discussion round <N> complete. What next?",
+        header: "Discussion Feedback",
+        multiSelect: false,
+        options: [
+          { label: "Continue deeper", description: "Current direction is good, go deeper" },
+          { label: "Adjust direction", description: "Shift analysis focus" },
+          { label: "Done", description: "Sufficient depth, proceed to synthesis" }
+        ]
+      }]
+    })
+```
+
+6. **Feedback handling** (after request_user_input returns):
+
+| Feedback | Action |
+|----------|--------|
+| "Continue deeper" | Create new DISCUSS-`<N+1>` task in tasks.json (pending, no deps). Record decision in discussion.md. Proceed to handleSpawnNext |
+| "Adjust direction" | request_user_input for new focus. Create ANALYZE-fix-`<N>` task in tasks.json (pending). Create DISCUSS-`<N+1>` task (pending, deps: [ANALYZE-fix-`<N>`]). Record direction change in discussion.md. Proceed to handleSpawnNext |
+| "Done" | Check if SYNTH-001 already exists in tasks.json: if yes, ensure deps is updated to reference last DISCUSS task; if no, create SYNTH-001 (pending, deps: [last DISCUSS]). Record decision in discussion.md. Proceed to handleSpawnNext |
+
+**Dynamic task creation** -- add entries to tasks.json `tasks` object:
+
+DISCUSS-N (subsequent round):
+```json
+{
+  "DISCUSS-<NNN>": {
+    "title": "Process discussion round <N>",
+    "description": "PURPOSE: Process discussion round <N> | Success: Updated understanding\nTASK:\n  - Process previous round results\n  - Execute <type> discussion strategy\n  - Update discussion timeline\nCONTEXT:\n  - Session: <session-folder>\n  - Topic: <topic>\n  - Round: <N>\n  - Type: <deepen|direction-adjusted|specific-questions>\n  - Shared memory: <session>/wisdom/.msg/meta.json\nEXPECTED: <session>/discussions/discussion-round-<NNN>.json\n---\nInnerLoop: false",
+    "role": "discussant",
+    "prefix": "DISCUSS",
+    "deps": [],
+    "status": "pending",
+    "findings": "",
+    "error": ""
+  }
+}
+```
+
+ANALYZE-fix-N (direction adjustment):
+```json
+{
+  "ANALYZE-fix-<N>": {
+    "title": "Supplementary analysis with adjusted focus",
+    "description": "PURPOSE: Supplementary analysis with adjusted focus | Success: New insights from adjusted direction\nTASK:\n  - Re-analyze from adjusted perspective: <adjusted_focus>\n  - Build on previous exploration findings\n  - Generate updated discussion points\nCONTEXT:\n  - Session: <session-folder>\n  - Topic: <topic>\n  - Type: direction-fix\n  - Adjusted focus: <adjusted_focus>\n  - Shared memory: <session>/wisdom/.msg/meta.json\nEXPECTED: <session>/analyses/analysis-fix-<N>.json\n---\nInnerLoop: false",
+    "role": "analyst",
+    "prefix": "ANALYZE",
+    "deps": [],
+    "status": "pending",
+    "findings": "",
+    "error": ""
+  }
+}
+```
+
+SYNTH-001 (created dynamically -- check existence first):
+```javascript
+// Guard: only create if SYNTH-001 doesn't exist yet in tasks.json
+if (!state.tasks['SYNTH-001']) {
+  state.tasks['SYNTH-001'] = {
+    title: "Integrate all analysis into final conclusions",
+    description: "PURPOSE: Integrate all analysis into final conclusions | Success: Executive summary with recommendations...",
+    role: "synthesizer",
+    prefix: "SYNTH",
+    deps: ["<last-DISCUSS-task-id>"],
+    status: "pending",
+    findings: "",
+    error: ""
+  }
+} else {
+  // Always update deps to reference the last DISCUSS task
+  state.tasks['SYNTH-001'].deps = ["<last-DISCUSS-task-id>"]
+}
+```
+
+7. Record user feedback to decision_trail via team_msg:
+
+```
+mcp__ccw-tools__team_msg({
+  operation: "log", session_id: sessionId, from: "coordinator",
+  type: "state_update",
+  data: { decision_trail_entry: {
+    round: discussion_round,
+    decision: feedback,
+    context: "User feedback at discussion round N",
+    timestamp: current ISO timestamp
+  }}
+})
+```
+
+8. Proceed to handleSpawnNext
+
+### handleSpawnNext
+
+Find and spawn the next ready tasks.
+
+1. Read tasks.json, find tasks where:
+   - Status is "pending"
+   - All deps tasks have status "completed"
+
+2. For each ready task, determine role from task prefix:
+
+| Task Prefix | Role | Role Spec |
+|-------------|------|-----------|
+| `EXPLORE-*` | explorer | `<skill_root>/roles/explorer/role.md` |
+| `ANALYZE-*` | analyst | `<skill_root>/roles/analyst/role.md` |
+| `DISCUSS-*` | discussant | `<skill_root>/roles/discussant/role.md` |
+| `SYNTH-*` | synthesizer | `<skill_root>/roles/synthesizer/role.md` |
+
+3. Spawn team_worker for each ready task:
+
+```javascript
+// 1) Update status in tasks.json
+state.tasks[taskId].status = 'in_progress'
+
+// 2) Spawn worker
+const agentId = spawn_agent({
+  agent_type: "team_worker",
+  items: [
+    { type: "text", text: `## Role Assignment
+role: ${role}
+role_spec: ${skillRoot}/roles/${role}/role.md
+session: ${sessionFolder}
+session_id: ${sessionId}
+requirement: ${taskDescription}
+agent_name: ${agentName}
+inner_loop: false` },
+
+    { type: "text", text: `## Current Task
+- Task ID: ${taskId}
+- Task: ${taskSubject}
+
+Read role_spec file to load Phase 2-4 domain instructions.
+Execute built-in Phase 1 (task discovery, owner=${agentName}) -> role-spec Phase 2-4 -> built-in Phase 5 (report).` }
+  ]
+})
+
+// 3) Track agent
+state.active_agents[taskId] = { agentId, role, started_at: now }
+```
+
+After spawning all ready tasks:
+
+```javascript
+// 4) Batch wait for all spawned workers
+const agentIds = Object.values(state.active_agents)
+  .map(a => a.agentId)
+wait_agent({ ids: agentIds })
+
+// 5) Collect results and update tasks.json
+for (const [taskId, agent] of Object.entries(state.active_agents)) {
+  state.tasks[taskId].status = 'completed'
+  delete state.active_agents[taskId]
+}
+```
+
+4. **Parallel spawn rules**:
+
+| Mode | Stage | Spawn Behavior |
+|------|-------|---------------|
+| quick | All stages | One worker at a time (serial pipeline) |
+| standard/deep | EXPLORE phase | Spawn all EXPLORE-001..N in parallel, wait_agent for all |
+| standard/deep | ANALYZE phase | Spawn all ANALYZE-001..N in parallel, wait_agent for all |
+| all | DISCUSS phase | One discussant at a time |
+| all | SYNTH phase | One synthesizer |
+
+5. **STOP** after processing -- wait for next event
+
+### handleCheck
+
+Output current pipeline status from tasks.json without advancing.
+
+```
+Pipeline Status (<mode> mode):
+  [DONE]  EXPLORE-001  (explorer)     -> exploration-001.json
+  [DONE]  EXPLORE-002  (explorer)     -> exploration-002.json
+  [DONE]  ANALYZE-001  (analyst)      -> analysis-001.json
+  [RUN]   ANALYZE-002  (analyst)      -> analyzing...
+  [WAIT]  DISCUSS-001  (discussant)   -> blocked by ANALYZE-002
+  [----]  SYNTH-001    (synthesizer)  -> blocked by DISCUSS-001
+
+Discussion Rounds: 0/<max>
+Pipeline Mode: <mode>
+Session: <session-id>
+```
+
+Output status -- do NOT advance pipeline.
+
+### handleResume
+
+Resume pipeline after user pause or interruption.
+
+1. Audit tasks.json for inconsistencies:
+   - Tasks stuck in "in_progress" -> reset to "pending"
+   - Tasks with completed deps but still "pending" -> include in spawn list
+2. Proceed to handleSpawnNext
+
+### handleComplete
+
+Triggered when all pipeline tasks are completed.
+
+**Completion check**:
+
+| Mode | Completion Condition |
+|------|---------------------|
+| quick | EXPLORE-001 + ANALYZE-001 + SYNTH-001 all completed |
+| standard | All EXPLORE + ANALYZE + DISCUSS-001 + SYNTH-001 completed |
+| deep | All EXPLORE + ANALYZE + all DISCUSS-N + SYNTH-001 completed |
+
+1. Verify all tasks completed in tasks.json. If any not completed, return to handleSpawnNext
+2. If all completed, **inline-execute coordinator Phase 5** (report + completion action). Do NOT STOP here -- continue directly into Phase 5 within the same turn.
+
+## Phase 4: State Persistence
+
+After every handler execution **except handleComplete**:
+
+1. Update tasks.json with current state:
+   - `discussion_round`: current round count
+   - `active_agents`: list of in-progress agents
+2. Verify task list consistency (no orphan tasks, no broken dependencies)
+3. **STOP** and wait for next event
+
+> **handleComplete exception**: handleComplete does NOT STOP -- it transitions directly to coordinator Phase 5.
+
+## Error Handling
+
+| Scenario | Resolution |
+|----------|------------|
+| Worker spawn fails | Retry once. If still fails, report to user via request_user_input: retry / skip / abort |
+| Discussion loop exceeds max rounds | Force create SYNTH-001, proceed to synthesis |
+| Synthesis fails | Report partial results from analyses and discussions |
+| Pipeline stall (no ready + no running) | Check deps chains, report blockage to user |
+| Missing task artifacts | Log warning, continue with available data |

package/.codex/skills/team-ultra-analyze/roles/coordinator/role.md

@@ -0,0 +1,223 @@
+# Coordinator - Ultra Analyze Team
+
+**Role**: coordinator
+**Type**: Orchestrator
+**Team**: ultra-analyze
+
+Orchestrates the analysis pipeline: topic clarification, pipeline mode selection, task dispatch, discussion loop management, and final synthesis. Spawns team_worker agents for all worker roles.
+
+## Boundaries
+
+### MUST
+
+- Use `team_worker` agent type for all worker spawns (NOT `general-purpose`)
+- Follow Command Execution Protocol for dispatch and monitor commands
+- Respect pipeline stage dependencies (deps)
+- Stop after spawning workers -- wait for results via wait_agent
+- Handle discussion loop with max 5 rounds (Deep mode)
+- Execute completion action in Phase 5
+
+### MUST NOT
+
+- Implement domain logic (exploring, analyzing, discussing, synthesizing) -- workers handle this
+- Spawn workers without creating tasks first
+- Skip checkpoints when configured
+- Force-advance pipeline past failed stages
+- Directly call cli-explore-agent, CLI analysis tools, or execute codebase exploration
+
+---
+
+## Command Execution Protocol
+
+When coordinator needs to execute a command (dispatch, monitor):
+
+1. **Read the command file**: `roles/coordinator/commands/<command-name>.md`
+2. **Follow the workflow** defined in the command file (Phase 2-4 structure)
+3. **Commands are inline execution guides** -- NOT separate agents or subprocesses
+4. **Execute synchronously** -- complete the command workflow before proceeding
+
+---
+
+## Entry Router
+
+When coordinator is invoked, detect invocation type:
+
+| Detection | Condition | Handler |
+|-----------|-----------|---------|
+| Status check | Arguments contain "check" or "status" | -> handleCheck (monitor.md) |
+| Manual resume | Arguments contain "resume" or "continue" | -> handleResume (monitor.md) |
+| Pipeline complete | All tasks have status "completed" | -> handleComplete (monitor.md) |
+| Interrupted session | Active/paused session exists | -> Phase 0 |
+| New session | None of above | -> Phase 1 |
+
+For check/resume/complete: load `@commands/monitor.md` and execute matched handler, then STOP.
+
+### Router Implementation
+
+1. **Load session context** (if exists):
+   - Scan `.workflow/.team/UAN-*/.msg/meta.json` for active/paused sessions
+   - If found, extract session folder path, status, and `pipeline_mode`
+
+2. **Parse $ARGUMENTS** for detection keywords:
+   - Check for "check", "status", "resume", "continue" keywords
+
+3. **Route to handler**:
+   - For monitor handlers: Read `commands/monitor.md`, execute matched handler, STOP
+   - For Phase 0: Execute Session Resume Check below
+   - For Phase 1: Execute Topic Understanding below
+
+---
+
+## Phase 0: Session Resume Check
+
+Triggered when an active/paused session is detected on coordinator entry.
+
+1. Load tasks.json from detected session folder
+2. Read tasks from tasks.json
+
+3. Reconcile session state vs task status:
+
+| Task Status | Session Expects | Action |
+|-------------|----------------|--------|
+| in_progress | Should be running | Reset to pending (worker was interrupted) |
+| completed | Already tracked | Skip |
+| pending + unblocked | Ready to run | Include in spawn list |
+
+4. Spawn workers for ready tasks -> Phase 4 coordination loop
+
+---
+
+## Phase 1: Topic Understanding & Requirement Clarification
+
+TEXT-LEVEL ONLY. No source code reading.
+
+1. Parse user task description from $ARGUMENTS
+2. Extract explicit settings: `--mode`, scope, focus areas
+3. Delegate to `@commands/analyze.md` for signal detection and pipeline mode selection
+4. **Interactive clarification** (non-auto mode): request_user_input for focus, perspectives, depth.
+
+---
+
+## Phase 2: Create Session + Initialize
+
+1. Resolve workspace paths (MUST do first):
+   - `project_root` = result of `Bash({ command: "pwd" })`
+   - `skill_root` = `<project_root>/.codex/skills/team-ultra-analyze`
+3. Generate session ID: `UAN-{slug}-{YYYY-MM-DD}`
+4. Create session folder structure:
+
+```
+.workflow/.team/UAN-{slug}-{date}/
++-- .msg/messages.jsonl
++-- .msg/meta.json
++-- discussion.md
++-- explorations/
++-- analyses/
++-- discussions/
++-- wisdom/
+    +-- learnings.md, decisions.md, conventions.md, issues.md
+```
+
+5. Write initial tasks.json:
+   ```json
+   {
+     "session_id": "<id>",
+     "pipeline_mode": "<Quick|Deep|Standard>",
+     "topic": "<topic>",
+     "perspectives": ["<perspective1>", "<perspective2>"],
+     "created_at": "<ISO timestamp>",
+     "discussion_round": 0,
+     "active_agents": {},
+     "tasks": {}
+   }
+   ```
+6. Initialize .msg/meta.json with pipeline metadata via team_msg:
+```typescript
+mcp__ccw-tools__team_msg({
+  operation: "log",
+  session_id: "<session-id>",
+  from: "coordinator",
+  type: "state_update",
+  summary: "Session initialized",
+  data: {
+    pipeline_mode: "<Quick|Deep|Standard>",
+    pipeline_stages: ["explorer", "analyst", "discussant", "synthesizer"],
+    roles: ["coordinator", "explorer", "analyst", "discussant", "synthesizer"]
+  }
+})
+```
+
+---
+
+## Phase 3: Create Task Chain
+
+Execute `@commands/dispatch.md` inline (Command Execution Protocol):
+1. Read `roles/coordinator/commands/dispatch.md`
+2. Follow dispatch Phase 2 -> Phase 3 -> Phase 4
+3. Result: all pipeline tasks created in tasks.json with correct deps
+
+---
+
+## Phase 4: Spawn & Coordination Loop
+
+### Initial Spawn
+
+Find first unblocked tasks and spawn their workers. Use SKILL.md Worker Spawn Template with:
+- `role_spec: <skill_root>/roles/<role>/role.md`
+- `inner_loop: false`
+
+**STOP** after spawning and waiting for results.
+
+### Coordination (via monitor.md handlers)
+
+All subsequent coordination is handled by `commands/monitor.md` handlers triggered after wait_agent returns.
+
+---
+
+## Phase 5: Report + Completion Action
+
+### Report
+
+1. Load session state -> count completed tasks, calculate duration
+2. List deliverables:
+
+| Deliverable | Path |
+|-------------|------|
+| Explorations | <session>/explorations/*.json |
+| Analyses | <session>/analyses/*.json |
+| Discussion | <session>/discussion.md |
+| Conclusions | <session>/conclusions.json |
+
+3. Include discussion summaries and decision trail
+4. Output pipeline summary: task count, duration, mode
+
+5. **Completion Action** (interactive):
+
+```
+request_user_input({
+  questions: [{
+    question: "Ultra-Analyze pipeline complete. What would you like to do?",
+    header: "Completion",
+    multiSelect: false,
+    options: [
+      { label: "Archive & Clean (Recommended)", description: "Archive session, clean up tasks and resources" },
+      { label: "Keep Active", description: "Keep session active for follow-up work or inspection" },
+      { label: "Export Results", description: "Export deliverables to a specified location, then clean" }
+    ]
+  }]
+})
+```
+
+6. Handle user choice per SKILL.md Completion Action section.
+
+---
+
+## Error Handling
+
+| Scenario | Resolution |
+|----------|------------|
+| Explorer finds nothing | Continue with limited context, note limitation |
+| Discussion loop stuck >5 rounds | Force synthesis, offer continuation |
+| CLI unavailable | Fallback chain: gemini -> codex -> claude |
+| User timeout in discussion | Save state, show resume command |
+| Session folder conflict | Append timestamp suffix |

package/.codex/skills/team-ultra-analyze/roles/discussant/role.md

@@ -0,0 +1,104 @@
+---
+role: discussant
+prefix: DISCUSS
+inner_loop: false
+message_types:
+  success: discussion_processed
+  error: error
+---
+
+# Discussant
+
+Process analysis results and user feedback. Execute direction adjustments, deep-dive explorations, or targeted Q&A based on discussion type. Update discussion timeline.
+
+## Phase 2: Context Loading
+
+| Input | Source | Required |
+|-------|--------|----------|
+| Task description | From task subject/description | Yes |
+| Session path | Extracted from task description | Yes |
+| Analysis results | `<session>/analyses/*.json` | Yes |
+| Exploration results | `<session>/explorations/*.json` | No |
+
+1. Extract session path, topic, round, discussion type, user feedback:
+
+| Field | Pattern | Default |
+|-------|---------|---------|
+| sessionFolder | `session:\s*(.+)` | required |
+| topic | `topic:\s*(.+)` | required |
+| round | `round:\s*(\d+)` | 1 |
+| discussType | `type:\s*(.+)` | "initial" |
+| userFeedback | `user_feedback:\s*(.+)` | empty |
+
+2. Read all analysis and exploration results
+3. Aggregate current findings, insights, open questions
+
+## Phase 3: Discussion Processing
+
+Select strategy by discussion type:
+
+| Type | Mode | Description |
+|------|------|-------------|
+| initial | inline | Aggregate all analyses: convergent themes, conflicts, top discussion points |
+| deepen | cli | Use CLI tool to investigate open questions deeper |
+| direction-adjusted | cli | Re-analyze via `ccw cli` from adjusted perspective |
+| specific-questions | cli | Targeted exploration answering user questions |
+
+**initial**: Cross-perspective summary -- identify convergent themes, conflicting views, top 5 discussion points and open questions from all analyses.
+
+**deepen**: Use CLI tool for deep investigation:
+```javascript
+Bash({
+  command: `ccw cli -p "PURPOSE: Investigate open questions and uncertain insights; success = evidence-based findings
+TASK: • Focus on open questions: <questions> • Find supporting evidence • Validate uncertain insights • Document findings
+MODE: analysis
+CONTEXT: @**/* | Memory: Session <session-folder>, previous analyses
+EXPECTED: JSON output with investigation results | Write to <session>/discussions/deepen-<num>.json
+CONSTRAINTS: Evidence-based analysis only
+" --tool gemini --mode analysis --rule analysis-trace-code-execution`,
+})
+```
+
+**direction-adjusted**: CLI re-analysis from adjusted focus:
+```javascript
+Bash({
+  command: `ccw cli -p "Re-analyze '<topic>' with adjusted focus on '<userFeedback>'" --tool gemini --mode analysis`,
+})
+```
+
+**specific-questions**: Use CLI tool for targeted Q&A:
+```javascript
+Bash({
+  command: `ccw cli -p "PURPOSE: Answer specific user questions about <topic>; success = clear, evidence-based answers
+TASK: • Answer: <userFeedback> • Provide code references • Explain context
+MODE: analysis
+CONTEXT: @**/* | Memory: Session <session-folder>
+EXPECTED: JSON output with answers and evidence | Write to <session>/discussions/questions-<num>.json
+CONSTRAINTS: Direct answers with code references
+" --tool gemini --mode analysis`,
+})
+```
+
+## Phase 4: Update Discussion Timeline
+
+1. Write round content to `<session>/discussions/discussion-round-<num>.json`:
+```json
+{
+  "round": 1, "type": "initial", "user_feedback": "...",
+  "updated_understanding": { "confirmed": [], "corrected": [], "new_insights": [] },
+  "new_findings": [], "new_questions": [], "timestamp": "..."
+}
+```
+
+2. Append round section to `<session>/discussion.md`:
+```markdown
+### Round <N> - Discussion (<timestamp>)
+#### Type: <discussType>
+#### User Input: <userFeedback or "(Initial discussion round)">
+#### Updated Understanding
+**Confirmed**: <list> | **Corrected**: <list> | **New Insights**: <list>
+#### New Findings / Open Questions
+```
+
+Update `<session>/wisdom/.msg/meta.json` under `discussant` namespace:
+- Read existing -> merge `{ "discussant": { round, type, new_insight_count, corrected_count } }` -> write back