@hanzlaa/rcode 4.1.0 → 4.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hanzlaa/rcode",
-  "version": "4.1.0",
+  "version": "4.1.1",
   "description": "rcode — the AI team that never forgets. Persistent memory, specialist agents, and slash commands for AI IDEs. Works in Claude Code, Cursor, Gemini, VS Code, and Antigravity.",
   "main": "cli/index.js",
   "bin": {

package/rcode/bin/lib/config.cjs

@@ -142,12 +142,13 @@ function cmdSet(projectRoot, dottedKey, value) {
   fs.mkdirSync(path.dirname(cp), { recursive: true });
   const existing = fs.existsSync(cp) ? fs.readFileSync(cp, 'utf8') : '';
   const config = parseNestedYaml(existing);
-  setAt(config, dottedKey, value);
+  const normalizedValue = stripQuotes(String(value).trim());
+  setAt(config, dottedKey, normalizedValue);
   const out = serialise(config);
   const tmp = cp + '.tmp';
   fs.writeFileSync(tmp, out, 'utf8');
   fs.renameSync(tmp, cp);
-  return { ok: true, key: dottedKey, value, path: cp };
+  return { ok: true, key: dottedKey, value: normalizedValue, path: cp };
 }
 
 module.exports = {

package/rcode/bin/rcode-tools.cjs

@@ -3170,7 +3170,9 @@ function cmdState(subArgs) {
       }
     }
 
-    // Walk .rcode/phases/*/sprint-*.md — parse sprints into state.sprints[] (issue #135).
+    // Walk phase sprint artifacts into state.sprints[] (issue #135).
+    // Support both legacy `sprint-1.md` and workflow-generated
+    // `01-01-SPRINT.md` / `1-1-SPRINT.md` names.
     const phasesDir = path.join(PLANNING_DIR, 'phases');
     const rcodePhasesDir = path.join(RCODE_DIR, 'phases');
     const sprintRoot = fs.existsSync(phasesDir) ? phasesDir : (fs.existsSync(rcodePhasesDir) ? rcodePhasesDir : null);
@@ -3182,9 +3184,11 @@ function cmdState(subArgs) {
         const phaseNumMatch = phaseEntry.match(/^(\d+(?:\.\d+)?)/);
         const phaseNum = phaseNumMatch ? phaseNumMatch[1] : phaseEntry;
         for (const file of fs.readdirSync(phaseDir)) {
-          const sprintMatch = file.match(/^sprint-(\d+)\.md$/);
+          const sprintMatch =
+            file.match(/^sprint-(\d+)\.md$/i) ||
+            file.match(/^(?:\d+(?:\.\d+)?[-_.])?(\d+)[-_.].*SPRINT\.md$/i);
           if (!sprintMatch) continue;
-          const sprintNum = sprintMatch[1];
+          const sprintNum = String(parseInt(sprintMatch[1], 10));
           const sprintKey = `${phaseNum}/${sprintNum}`;
           parsed.sprints_found += 1;
           const sprintPath = path.join(phaseDir, file);
@@ -6795,6 +6799,7 @@ function cmdGitignore(args) {
     '.rcode/brain/best-practices/',
     '',
     '# Runtime noise',
+    'node_modules/',
     '.rcode/state.json.lock',
     '.planning/debug/',
     '.planning/_backup/',

package/rcode/skills/actions/3-solutioning/rcode-create-architecture/steps/step-01-init.md

@@ -70,7 +70,7 @@ Try to discover the following:
 - Project Documentation (generally multiple documents might be found for this in the `{project_knowledge}` or `{project-root}/docs` folder.)
 - Project Context (`**/project-context.md`)
 
-<critical>Confirm what you have found with the user, along with asking if the user wants to provide anything else. Only after this confirmation will you proceed to follow the loading rules</critical>
+<critical>If auto mode is active (--auto flag or config.mode == "yolo"): skip user confirmation — log "Auto mode: proceeding with discovered documents: [list]" and continue directly to Loading Rules. Otherwise: confirm what you have found with the user, ask if they want to provide anything else, and only proceed after confirmation.</critical>
 
 **Loading Rules:**
 

package/rcode/skills/actions/3-solutioning/rcode-create-architecture/workflow.md

@@ -18,14 +18,26 @@ This uses **micro-file architecture** for disciplined execution:
 
 ---
 
+## AUTO MODE
+
+**If `--auto` was passed in ARGUMENTS OR `config.mode == "yolo"`:**
+- Skip all user-confirmation gates throughout the workflow.
+- In step-01-init: discover input documents automatically, proceed without asking the user to confirm or add files.
+- In all subsequent steps: choose the recommended option at every decision point without prompting.
+- Log each auto-selected choice inline so the output is auditable.
+- This flag persists for the entire workflow invocation (all steps see it).
+
+---
+
 ## INITIALIZATION
 
 ### Configuration Loading
 
-Load config from `{project-root}/.rcode/config.json` and resolve:
+Load config from `{project-root}/.rcode/config.yaml` and resolve:
 
 - `project_name`, `output_folder`, `planning_artifacts`, `user_name`
 - `communication_language`, `document_output_language`, `user_skill_level`
+- `mode` — if `yolo`, treat as `--auto` for this entire invocation
 - `date` as system-generated current datetime
 - ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
 

package/rcode/skills/actions/4-implementation/rcode-herdr-orchestration/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: rcode-herdr-orchestration
-description: Orchestrate parallel cld agents in herdr — single-shot fan-out OR long-running autonomous wave-based fix campaign with durable backlog and integration branch. Do NOT use for a single quick task; invoke directly without herdr for that.
+description: Orchestrate parallel cld agents in herdr — fan-out or autonomous wave campaign.
 triggers:
   # English — single-shot orchestration
   - "orchestrate agents"
@@ -50,6 +50,10 @@ Two modes: **single-shot** (bounded fan-out, one sitting, merge back done) and
 branch). Both share the same golden rules and pane mechanics. See `references.md` for
 the full campaign workflow and deep-dive rules.
 
+**Do NOT use for a single quick task** — invoke the work directly without herdr for that.
+Orchestration overhead (worktrees, panes, monitoring) only pays off across multiple
+independent agents.
+
 ---
 
 ## Golden rules (NON-NEGOTIABLE — apply to BOTH modes)

package/rcode/skills/actions/4-implementation/rcode-retrospective/workflow.md

@@ -34,11 +34,30 @@ This keeps `.rcode/state.json` in sync with disk — `/rcode-progress`, `/rcode-
 
 ---
 
+## AUTO MODE (--auto / yolo)
+
+**If `--auto` was passed OR `config.mode == "yolo"`:** skip all `<action>WAIT</action>` gates,
+skip all roleplay dialog (Bob/Alice/Charlie personas), and produce the retrospective document
+directly from available artifacts.
+
+Auto-mode steps:
+1. Load config + resolve paths (same as INITIALIZATION below).
+2. Detect epic number automatically (highest epic in sprint-status or implementation_artifacts).
+3. Read epic file, SUMMARY.md, and previous retrospective if present.
+4. Produce the retrospective markdown document at `{implementation_artifacts}/epic-{N}-retro-{date}.md`
+   with sections: Epic Summary, Metrics, Successes, Challenges, Key Learnings, Action Items,
+   Next Epic Preparation.
+5. Update sprint-status.yaml to mark `epic-{N}-retrospective` as done.
+6. Run `node .rcode/bin/rcode-tools.cjs state sync --from-disk`.
+7. Print completion banner and stop — do not run the interactive EXECUTION steps below.
+
+---
+
 ## INITIALIZATION
 
 ### Configuration Loading
 
-Load config from `{project-root}/.rcode/config.json` and resolve:
+Load config from `{project-root}/.rcode/config.yaml` and resolve:
 
 - `project_name`, `user_name`
 - `communication_language`, `document_output_language`
@@ -495,83 +514,26 @@ Bob (Scrum Master): "No problem. We'll still do a thorough retro on Epic {{epic_
 <action>Ensure key roles present: Product Owner, Scrum Master (facilitating), Devs, Testing/QA, Architect</action>
 
 <output>
-Bob (Scrum Master): "Alright team, everyone's here. Let me set the stage for our retrospective."
-
 ═══════════════════════════════════════════════════════════
 🔄 TEAM RETROSPECTIVE - Epic {{epic_number}}: {{epic_title}}
 ═══════════════════════════════════════════════════════════
 
-Bob (Scrum Master): "Here's what we accomplished together."
-
 **EPIC {{epic_number}} SUMMARY:**
 
-Delivery Metrics:
-
-- Completed: {{completed_stories}}/{{total_stories}} stories ({{completion_percentage}}%)
-- Velocity: {{actual_points}} story points{{#if planned_points}} (planned: {{planned_points}}){{/if}}
-- Duration: {{actual_sprints}} sprints{{#if planned_sprints}} (planned: {{planned_sprints}}){{/if}}
-- Average velocity: {{points_per_sprint}} points/sprint
-
-Quality and Technical:
-
-- Blockers encountered: {{blocker_count}}
-- Technical debt items: {{debt_count}}
-- Test coverage: {{coverage_info}}
-- Production incidents: {{incident_count}}
-
-Business Outcomes:
-
-- Goals achieved: {{goals_met}}/{{total_goals}}
-- Success criteria: {{criteria_status}}
-- Stakeholder feedback: {{feedback_summary}}
-
-Alice (Product Owner): "Those numbers tell a good story. {{completion_percentage}}% completion is {{#if completion_percentage >= 90}}excellent{{else}}something we should discuss{{/if}}."
-
-Charlie (Senior Dev): "I'm more interested in that technical debt number - {{debt_count}} items is {{#if debt_count > 10}}concerning{{else}}manageable{{/if}}."
-
-Dana (QA Engineer): "{{incident_count}} production incidents - {{#if incident_count == 0}}clean epic!{{else}}we should talk about those{{/if}}."
+Delivery: {{completed_stories}}/{{total_stories}} stories ({{completion_percentage}}%) · {{actual_points}} pts · {{actual_sprints}} sprints · {{points_per_sprint}} pts/sprint avg
+Quality: {{blocker_count}} blockers · {{debt_count}} tech-debt items · {{coverage_info}} coverage · {{incident_count}} incidents
+Outcomes: {{goals_met}}/{{total_goals}} goals · {{criteria_status}} · {{feedback_summary}}
 
 {{#if next_epic_exists}}
-═══════════════════════════════════════════════════════════
 **NEXT EPIC PREVIEW:** Epic {{next_epic_num}}: {{next_epic_title}}
-═══════════════════════════════════════════════════════════
-
-Dependencies on Epic {{epic_number}}:
-{{list_dependencies}}
-
-Preparation Needed:
-{{list_preparation_gaps}}
-
-Technical Prerequisites:
-{{list_technical_prereqs}}
-
-Bob (Scrum Master): "And here's what's coming next. Epic {{next_epic_num}} builds on what we just finished."
-
-Elena (Junior Dev): "Wow, that's a lot of dependencies on our work."
-
-Charlie (Senior Dev): "Which means we better make sure Epic {{epic_number}} is actually solid before moving on."
+Dependencies: {{list_dependencies}}
+Preparation gaps: {{list_preparation_gaps}}
+Technical prerequisites: {{list_technical_prereqs}}
 {{/if}}
 
-═══════════════════════════════════════════════════════════
-
-Bob (Scrum Master): "Team assembled for this retrospective:"
-
-{{list_participating_agents}}
-
-Bob (Scrum Master): "{user_name}, you're joining us as Project Lead. Your perspective is crucial here."
-
-{user_name} (Project Lead): [Participating in the retrospective]
-
-Bob (Scrum Master): "Our focus today:"
-
-1. Learning from Epic {{epic_number}} execution
-   {{#if next_epic_exists}}2. Preparing for Epic {{next_epic_num}} success{{/if}}
-
-Bob (Scrum Master): "Ground rules: psychological safety first. No blame, no judgment. We focus on systems and processes, not individuals. Everyone's voice matters. Specific examples are better than generalizations."
-
-Alice (Product Owner): "And everything shared here stays in this room - unless we decide together to escalate something."
-
-Bob (Scrum Master): "Exactly. {user_name}, any questions before we dive in?"
+Participants: {{list_participating_agents}} + {user_name} (Project Lead)
+Focus: (1) Learn from Epic {{epic_number}} · {{#if next_epic_exists}}(2) Prepare Epic {{next_epic_num}}{{/if}}
+Ground rules: No blame — systems focus — psychological safety — specific examples preferred.
 </output>
 
 <action>WAIT for {user_name} to respond or indicate readiness</action>
@@ -874,49 +836,19 @@ Bob (Scrum Master): "I want specific, achievable actions with clear owners. Not
 - Time-bound: Has clear deadline
 
 <output>
-Bob (Scrum Master): "Based on our discussion, here are the action items I'm proposing..."
-
 ═══════════════════════════════════════════════════════════
 📝 EPIC {{epic_number}} ACTION ITEMS:
 ═══════════════════════════════════════════════════════════
 
 **Process Improvements:**
-
-1. {{action_item_1}}
-   Owner: {{agent_1}}
-   Deadline: {{timeline_1}}
-   Success criteria: {{criteria_1}}
-
-2. {{action_item_2}}
-   Owner: {{agent_2}}
-   Deadline: {{timeline_2}}
-   Success criteria: {{criteria_2}}
-
-Charlie (Senior Dev): "I can own action item 1, but {{timeline_1}} is tight. Can we push it to {{alternative_timeline}}?"
-
-Bob (Scrum Master): "What do others think? Does that timing still work?"
-
-Alice (Product Owner): "{{alternative_timeline}} works for me, as long as it's done before Epic {{next_epic_num}} starts."
-
-Bob (Scrum Master): "Agreed. Updated to {{alternative_timeline}}."
+1. {{action_item_1}} — Owner: {{agent_1}} · Due: {{timeline_1}} · Success: {{criteria_1}}
+2. {{action_item_2}} — Owner: {{agent_2}} · Due: {{timeline_2}} · Success: {{criteria_2}}
 
 **Technical Debt:**
+1. {{debt_item_1}} — Owner: {{agent_3}} · Priority: {{priority_1}} · Effort: {{effort_1}}
+2. {{debt_item_2}} — Owner: {{agent_4}} · Priority: {{priority_2}} · Effort: {{effort_2}}
 
-1. {{debt_item_1}}
-   Owner: {{agent_3}}
-   Priority: {{priority_1}}
-   Estimated effort: {{effort_1}}
-
-2. {{debt_item_2}}
-   Owner: {{agent_4}}
-   Priority: {{priority_2}}
-   Estimated effort: {{effort_2}}
-
-Dana (QA Engineer): "For debt item 1, can we prioritize that as high? It caused testing issues in three different stories."
-
-Charlie (Senior Dev): "I marked it medium because {{reasoning}}, but I hear your point."
-
-Bob (Scrum Master): "{user_name}, this is a priority call. Testing impact vs. {{reasoning}} - how do you want to prioritize it?"
+{user_name}, debt item 1 priority is a call you need to make — testing impact vs. {{reasoning}}.
 </output>
 
 <action>WAIT for {user_name} to help resolve priority discussions</action>
@@ -998,59 +930,20 @@ Estimated: {{est_4}}
 
 <check if="significant discoveries detected">
   <output>
+🚨 SIGNIFICANT DISCOVERY — Epic {{next_epic_num}} plan needs review
 
-═══════════════════════════════════════════════════════════
-🚨 SIGNIFICANT DISCOVERY ALERT 🚨
-═══════════════════════════════════════════════════════════
-
-Bob (Scrum Master): "{user_name}, we need to flag something important."
-
-Bob (Scrum Master): "During Epic {{epic_number}}, the team uncovered findings that may require updating the plan for Epic {{next_epic_num}}."
-
-**Significant Changes Identified:**
+Changes identified:
+1. {{significant_change_1}} — Impact: {{impact_description_1}}
+2. {{significant_change_2}} — Impact: {{impact_description_2}}
+{{#if significant_change_3}}3. {{significant_change_3}} — Impact: {{impact_description_3}}{{/if}}
 
-1. {{significant_change_1}}
-   Impact: {{impact_description_1}}
-
-2. {{significant_change_2}}
-   Impact: {{impact_description_2}}
-
-{{#if significant_change_3}} 3. {{significant_change_3}}
-Impact: {{impact_description_3}}
-{{/if}}
+Epic {{next_epic_num}} currently assumes: {{wrong_assumption_1}} / {{wrong_assumption_2}}
+Epic {{epic_number}} revealed: {{actual_reality_1}} / {{actual_reality_2}}
+Changes needed: {{list_likely_changes_needed}}
 
-Charlie (Senior Dev): "Yeah, when we discovered {{technical_discovery}}, it fundamentally changed our understanding of {{affected_area}}."
+Recommended: review Epic {{next_epic_num}} definition · update affected stories · hold alignment session{{#if prd_update_needed}} · update PRD{{/if}}
 
-Alice (Product Owner): "And from a product perspective, {{product_discovery}} means Epic {{next_epic_num}}'s stories are based on wrong assumptions."
-
-Dana (QA Engineer): "If we start Epic {{next_epic_num}} as-is, we're going to hit walls fast."
-
-**Impact on Epic {{next_epic_num}}:**
-
-The current plan for Epic {{next_epic_num}} assumes:
-
-- {{wrong_assumption_1}}
-- {{wrong_assumption_2}}
-
-But Epic {{epic_number}} revealed:
-
-- {{actual_reality_1}}
-- {{actual_reality_2}}
-
-This means Epic {{next_epic_num}} likely needs:
-{{list_likely_changes_needed}}
-
-**RECOMMENDED ACTIONS:**
-
-1. Review and update Epic {{next_epic_num}} definition based on new learnings
-2. Update affected stories in Epic {{next_epic_num}} to reflect reality
-3. Consider updating architecture or technical specifications if applicable
-4. Hold alignment session with Product Owner before starting Epic {{next_epic_num}}
-   {{#if prd_update_needed}}5. Update PRD sections affected by new understanding{{/if}}
-
-Bob (Scrum Master): "**Epic Update Required**: YES - Schedule epic planning review session"
-
-Bob (Scrum Master): "{user_name}, this is significant. We need to address this before committing to Epic {{next_epic_num}}'s current plan. How do you want to handle it?"
+{user_name}: how do you want to handle this before committing to Epic {{next_epic_num}}'s current plan?
 </output>
 
 <action>WAIT for {user_name} to decide on how to handle the significant changes</action>
@@ -1274,61 +1167,27 @@ Charlie (Senior Dev): "Better to catch this now than three stories into the next
 <step n="10" goal="Retrospective Closure with Celebration and Commitment">
 
 <output>
-Bob (Scrum Master): "We've covered a lot of ground today. Let me bring this retrospective to a close."
-
 ═══════════════════════════════════════════════════════════
-✅ RETROSPECTIVE COMPLETE
+✅ RETROSPECTIVE COMPLETE — Epic {{epic_number}}: {{epic_title}}
 ═══════════════════════════════════════════════════════════
 
-Bob (Scrum Master): "Epic {{epic_number}}: {{epic_title}} - REVIEWED"
-
 **Key Takeaways:**
-
 1. {{key_lesson_1}}
 2. {{key_lesson_2}}
 3. {{key_lesson_3}}
-   {{#if key_lesson_4}}4. {{key_lesson_4}}{{/if}}
-
-Alice (Product Owner): "That first takeaway is huge - {{impact_of_lesson_1}}."
-
-Charlie (Senior Dev): "And lesson 2 is something we can apply immediately."
-
-Bob (Scrum Master): "Commitments made today:"
-
-- Action Items: {{action_count}}
-- Preparation Tasks: {{prep_task_count}}
-- Critical Path Items: {{critical_count}}
-
-Dana (QA Engineer): "That's a lot of commitments. We need to actually follow through this time."
+{{#if key_lesson_4}}4. {{key_lesson_4}}{{/if}}
 
-Bob (Scrum Master): "Agreed. Which is why we'll review these action items in our next standup."
+Commitments: {{action_count}} action items · {{prep_task_count}} prep tasks · {{critical_count}} critical path items
 
-═══════════════════════════════════════════════════════════
-🎯 NEXT STEPS:
-═══════════════════════════════════════════════════════════
-
-1. Execute Preparation Sprint (Est: {{prep_days}} days)
-2. Complete Critical Path items before Epic {{next_epic_num}}
+**Next Steps:**
+1. Execute Preparation Sprint ({{prep_days}} days)
+2. Complete critical path items before Epic {{next_epic_num}}
 3. Review action items in next standup
-   {{#if epic_update_needed}}4. Hold Epic {{next_epic_num}} planning review session{{else}}4. Begin Epic {{next_epic_num}} planning when preparation complete{{/if}}
-
-Elena (Junior Dev): "{{prep_days}} days of prep work is significant, but necessary."
+{{#if epic_update_needed}}4. Hold Epic {{next_epic_num}} planning review{{else}}4. Begin Epic {{next_epic_num}} planning when prep complete{{/if}}
 
-Alice (Product Owner): "I'll communicate the timeline to stakeholders. They'll understand if we frame it as 'ensuring Epic {{next_epic_num}} success.'"
+Epic {{epic_number}} delivered {{completed_stories}} stories with {{velocity_description}} velocity across {{blocker_count}} blockers.
 
-═══════════════════════════════════════════════════════════
-
-Bob (Scrum Master): "Before we wrap, I want to take a moment to acknowledge the team."
-
-Bob (Scrum Master): "Epic {{epic_number}} delivered {{completed_stories}} stories with {{velocity_description}} velocity. We overcame {{blocker_count}} blockers. We learned a lot. That's real work by real people."
-
-Charlie (Senior Dev): "Hear, hear."
-
-Alice (Product Owner): "I'm proud of what we shipped."
-
-Dana (QA Engineer): "And I'm excited about Epic {{next_epic_num}} - especially now that we're prepared for it."
-
-Bob (Scrum Master): "{user_name}, any final thoughts before we close?"
+{user_name}, any final thoughts before we close?
 </output>
 
 <action>WAIT for {user_name} to share final reflections</action>
@@ -1409,61 +1268,17 @@ Retrospective document was saved successfully, but {sprint_status_file} may need
 <output>
 **✅ Retrospective Complete, {user_name}!**
 
-**Epic Review:**
-
-- Epic {{epic_number}}: {{epic_title}} reviewed
-- Retrospective Status: completed
-- Retrospective saved: {implementation_artifacts}/epic-{{epic_number}}-retro-{date}.md
-
-**Commitments Made:**
-
-- Action Items: {{action_count}}
-- Preparation Tasks: {{prep_task_count}}
-- Critical Path Items: {{critical_count}}
+Epic {{epic_number}}: {{epic_title}} — retrospective saved: `{implementation_artifacts}/epic-{{epic_number}}-retro-{date}.md`
+Commitments: {{action_count}} action items · {{prep_task_count}} prep tasks · {{critical_count}} critical path items
 
 **Next Steps:**
+1. Review `{implementation_artifacts}/epic-{{epic_number}}-retro-{date}.md`
+2. Execute preparation sprint (~{{prep_days}} days) — {{critical_count}} critical items + {{prep_task_count}} prep tasks
+3. Review action items in next standup
+{{#if epic_update_needed}}4. ⚠️ SCHEDULE Epic {{next_epic_num}} planning review — do NOT start until complete{{else}}4. Begin Epic {{next_epic_num}} when prep complete{{/if}}
 
-1. **Review retrospective summary**: {implementation_artifacts}/epic-{{epic_number}}-retro-{date}.md
-
-2. **Execute preparation sprint** (Est: {{prep_days}} days)
-   - Complete {{critical_count}} critical path items
-   - Execute {{prep_task_count}} preparation tasks
-   - Verify all action items are in progress
-
-3. **Review action items in next standup**
-   - Ensure ownership is clear
-   - Track progress on commitments
-   - Adjust timelines if needed
-
-{{#if epic_update_needed}} 4. **IMPORTANT: Schedule Epic {{next_epic_num}} planning review session**
-
-- Significant discoveries from Epic {{epic_number}} require epic updates
-- Review and update affected stories
-- Align team on revised approach
-- Do NOT start Epic {{next_epic_num}} until review is complete
-  {{else}}
-
-4. **Begin Epic {{next_epic_num}} when ready**
-   - Start creating stories with SM agent's `create-story`
-   - Epic will be marked as `in-progress` automatically when first story is created
-   - Ensure all critical path items are done first
-     {{/if}}
-
-**Team Performance:**
-Epic {{epic_number}} delivered {{completed_stories}} stories with {{velocity_summary}}. The retrospective surfaced {{insight_count}} key insights and {{significant_discovery_count}} significant discoveries. The team is well-positioned for Epic {{next_epic_num}} success.
-
-{{#if significant_discovery_count > 0}}
-⚠️ **REMINDER**: Epic update required before starting Epic {{next_epic_num}}
-{{/if}}
-
----
-
-Bob (Scrum Master): "Great session today, {user_name}. The team did excellent work."
-
-Alice (Product Owner): "See you at epic planning!"
-
-Charlie (Senior Dev): "Time to knock out that prep work."
-
+Epic {{epic_number}}: {{completed_stories}} stories · {{velocity_summary}} · {{insight_count}} insights · {{significant_discovery_count}} discoveries
+{{#if significant_discovery_count > 0}}⚠️ Epic update required before starting Epic {{next_epic_num}}{{/if}}
 </output>
 
 </step>

package/rcode/workflows/audit.md

@@ -18,6 +18,7 @@ If `$ARGUMENTS` contains `--help` or `-h`:
 
 ```
 /rcode-audit                           # interactive — asks what to audit
+/rcode-audit --auto                    # non-interactive — auto-picks best target from project state
 /rcode-audit plans [--report]         # → audit-plans (structural + status + deps check)
 /rcode-audit phase [<NN>]              # → /rcode-verify-phase
 /rcode-audit milestone [--strict]      # → /rcode-audit-milestone (with synth fallback)
@@ -49,6 +50,8 @@ DISCUSS=$($TOOL config-get workflow.discuss_mode 2>/dev/null || echo "adaptive")
 ```
 
 Parse `$ARGUMENTS`:
+- If `--auto` flag is present: strip it from args and force `MODE=yolo` for this invocation
+  (allows non-interactive runs without permanently changing the project config).
 - First word ∈ {plans, phase, milestone, uat, code, fix, work, lens, worktrees} → set `$TARGET`, drop it from args, jump to Step 4.
 - Empty or unrecognised → continue to Step 2.
 

package/rcode/workflows/brainstorm.md

@@ -40,7 +40,7 @@ AskUserQuestion(
 
 ## Step 2 — Load brainstorming methods
 
-Read `rcode/references/brain-methods.csv` and parse it.
+Read `.rcode/references/brain-methods.csv` and parse it.
 
 If `--method` was specified:
 - Validate the method exists in the CSV

package/rcode/workflows/council.md

@@ -29,9 +29,10 @@ Closure: `rcode ► COUNCIL COMPLETE ✓` + Next Up with decision options.
 
 <required_reading>
 @.rcode/references/auto-init-guard.md
-@.rcode/references/output-format.md
 @.rcode/references/council-protocol.md
 </required_reading>
+<!-- output-format.md removed: council is self-contained via <output_format> above.
+     General banner/todo/spawn patterns are defined inline — no 398-line load needed. -->
 
 <process>
 ## Step 0 — Usage check
@@ -101,6 +102,12 @@ list from INIT_JSON so new agents added to team.yaml are automatically available
 Do not invoke `general-purpose` or any agent type not present in
 `installed_agents`. If the scorer surfaces an unknown agent, drop it
 from the panel silently.
+
+**Post-install agent namespace fallback:** If a `Task(subagent_type="rcode-{id}")` call
+fails with "Agent type not found", the runtime has not yet registered the new agent files
+(requires IDE/window reload). In that case retry with `subagent_type="rihal-{id}"` — the
+`rihal-*` agents are content-identical to `rcode-*` (pre-rebrand names). If neither works,
+skip that panelist and log `[council] agent rcode-{id} not available — reload IDE to register`.
 </available_agent_types>
 
 ## Step 1 — Observe

package/rcode/workflows/create-architecture.md

@@ -9,7 +9,11 @@ Write an Architecture Decision Record (ADR) or system design document. Delegates
 Locate and follow the installed skill:
 
 ```bash
-find .rcode/skills/actions -path "*rcode-create-architecture/workflow.md" 2>/dev/null | head -1
+if [ -f .rcode/skills/rcode-create-architecture/workflow.md ]; then
+  printf '%s\n' ".rcode/skills/rcode-create-architecture/workflow.md"
+else
+  find .rcode/skills/actions -path "*rcode-create-architecture/workflow.md" 2>/dev/null | head -1
+fi
 ```
 
 Read and follow the workflow at that path. If the path is empty:

package/rcode/workflows/create-prd.md

@@ -9,7 +9,11 @@ Create a Product Requirements Document from scratch through guided facilitation.
 Locate and follow the installed skill:
 
 ```bash
-find .rcode/skills/actions -path "*rcode-create-prd/workflow.md" 2>/dev/null | head -1
+if [ -f .rcode/skills/rcode-create-prd/workflow.md ]; then
+  printf '%s\n' ".rcode/skills/rcode-create-prd/workflow.md"
+else
+  find .rcode/skills/actions -path "*rcode-create-prd/workflow.md" 2>/dev/null | head -1
+fi
 ```
 
 Read and follow the workflow at that path. If the path is empty:

package/rcode/workflows/dashboard.md

@@ -33,8 +33,11 @@ if [ -f ./server/dashboard.js ]; then
 # 2. Installed package copy inside project
 elif [ -f ./.rcode/lib/server/dashboard.js ]; then
   DASHBOARD="./.rcode/lib/server/dashboard.js"
+# 3. Local npm dependency install
+elif [ -f ./node_modules/@hanzlaa/rcode/server/dashboard.js ]; then
+  DASHBOARD="./node_modules/@hanzlaa/rcode/server/dashboard.js"
 else
-  # 3. Global installs — check npm, pnpm, and yarn roots
+  # 4. Global installs — check npm, pnpm, and yarn roots
   for ROOT in "$(npm root -g 2>/dev/null)" "$(pnpm root -g 2>/dev/null)" "$(yarn global dir 2>/dev/null)/node_modules"; do
     [ -z "$ROOT" ] && continue
     if [ -f "$ROOT/@hanzlaa/rcode/server/dashboard.js" ]; then
@@ -42,7 +45,7 @@ else
       break
     fi
   done
-  # 4. Last resort — resolve via the rcode/rcode binary symlink
+  # 5. Last resort — resolve via the rcode/rcode binary symlink
   if [ -z "$DASHBOARD" ]; then
     for BIN in rcode; do
       BIN_PATH="$(command -v $BIN 2>/dev/null)" || continue

package/rcode/workflows/discuss-phase.md

@@ -39,21 +39,9 @@ Only include domain-probes.md when `HAS_PRODUCT_SIGNALS` is 0.
 </downstream_awareness>
 
 <philosophy>
-**User = founder/visionary. Claude = builder.**
-
-The user knows:
-- How they imagine it working
-- What it should look/feel like
-- What's essential vs nice-to-have
-- Specific behaviors or references they have in mind
-
-The user doesn't know (and shouldn't be asked):
-- Codebase patterns (researcher reads the code)
-- Technical risks (researcher identifies these)
-- Implementation approach (planner figures this out)
-- Success metrics (inferred from the work)
-
-Ask about vision and implementation choices. Capture decisions for downstream agents.
+User = visionary (knows what, not how). Claude = builder (asks about choices, not implementation).
+Ask about vision and decisions. Capture for downstream agents. Never ask about codebase patterns,
+technical risks, or architecture — those are research/planner territory.
 </philosophy>
 
 <scope_guardrail>