@hanzlaa/rcode 2.2.0 → 2.3.2

package/server/lib/scanner.js

@@ -0,0 +1,142 @@
+/**
+ * State scanner — reads .rihal/ and .planning/ directories to build dashboard state.
+ */
+const fs = require('fs');
+const path = require('path');
+
+function safeReadJson(filepath) {
+  let raw;
+  try { raw = fs.readFileSync(filepath, 'utf8'); } catch { return null; }
+  try { return JSON.parse(raw); } catch (err) {
+    console.warn(`[dashboard] malformed JSON at ${filepath}: ${err.message}`);
+    return { __parseError: err.message };
+  }
+}
+
+function safeReadText(filepath) {
+  try { return fs.readFileSync(filepath, 'utf8'); } catch { return null; }
+}
+
+function listDir(dir) {
+  try { return fs.readdirSync(dir, { withFileTypes: true }); } catch { return []; }
+}
+
+function parseSimpleYaml(text) {
+  if (!text) return {};
+  const out = {};
+  for (const line of text.split('\n')) {
+    const m = line.match(/^([a-zA-Z_][a-zA-Z0-9_]*)\s*:\s*(.+)/);
+    if (m) out[m[1].trim()] = m[2].trim();
+  }
+  return out;
+}
+
+function scanState(rihalDir) {
+  const projectDir = path.dirname(rihalDir);
+  const state = {
+    exists: fs.existsSync(rihalDir),
+    projectName: null,
+    raw: null,
+    rawParseError: null,
+    phases: [],
+    decisions: [],
+    blockers: [],
+    councilSessions: 0,
+    milestone: null,
+    currentPhase: null,
+    currentSprint: null,
+    planningFiles: [],
+    context: null,
+    lastScanned: new Date().toISOString(),
+  };
+
+  if (!state.exists) return state;
+
+  const rawResult = safeReadJson(path.join(rihalDir, 'state.json'));
+  if (rawResult && rawResult.__parseError) {
+    state.rawParseError = rawResult.__parseError;
+    state.raw = null;
+  } else {
+    state.raw = rawResult;
+  }
+
+  const cfg = parseSimpleYaml(safeReadText(path.join(rihalDir, 'config.yaml')));
+
+  // Fix #260: project name shows '.' — derive from directory name as fallback
+  const dirName = path.basename(projectDir);
+  state.projectName = state.raw?.project_name
+    || cfg.project_name
+    || state.raw?.project
+    || (dirName !== '.' ? dirName : 'Unknown project');
+
+  state.currentPhase   = state.raw?.current_phase  || null;
+  state.currentSprint  = state.raw?.current_sprint || null;
+  state.milestone      = state.raw?.milestone       || null;
+  state.councilSessions = (state.raw?.council_sessions || []).length;
+
+  if (Array.isArray(state.raw?.phases)) {
+    const phasesDir = path.join(projectDir, '.planning', 'phases');
+    state.phases = state.raw.phases.map(p => {
+      const sprints    = Array.isArray(p.sprints) ? p.sprints : [];
+      const allStories = sprints.flatMap(s => Array.isArray(s.stories) ? s.stories : []);
+      const done  = allStories.filter(s => s.status === 'done' || s.status === 'completed').length;
+      const total = allStories.length;
+
+      const padded = String(p.id || p.number || '').padStart(2, '0');
+      let phaseDir = null, sprintFile = null;
+      try {
+        const dirs = fs.readdirSync(phasesDir, { withFileTypes: true });
+        const match = dirs.find(d => d.isDirectory() && d.name.startsWith(padded + '-'));
+        if (match) {
+          phaseDir = match.name;
+          const allMd = fs.readdirSync(path.join(phasesDir, match.name)).filter(f => f.endsWith('.md'));
+          const numbered = allMd.filter(f => /^\d{2}-\d{2}-/.test(f)).sort().reverse();
+          const chosen = numbered.length ? numbered[0] : allMd.sort().reverse()[0];
+          if (chosen) sprintFile = `.planning/phases/${match.name}/${chosen}`;
+        }
+      } catch { /* phasesDir missing */ }
+
+      return {
+        id: p.id,
+        name: p.name || p.slug || p.id,
+        status: p.status || (sprints[0]?.status) || 'planned',
+        sprints: sprints.length,
+        stories: total,
+        storiesDone: done,
+        goal: sprints[0]?.goal || null,
+        completed_at: p.completed_at || null,
+        sprintFile,
+      };
+    });
+  }
+
+  if (Array.isArray(state.raw?.decisions)) {
+    state.decisions = state.raw.decisions;
+  }
+
+  if (Array.isArray(state.raw?.blockers)) {
+    state.blockers = state.raw.blockers.filter(b => b && (typeof b === 'string' || b.title));
+  }
+
+  state.context = safeReadText(path.join(rihalDir, 'context', 'active.md'))
+    || safeReadText(path.join(projectDir, '.planning', 'CONTEXT.md'));
+
+  // Walk .planning/ for file tree
+  const planningDir = path.join(projectDir, '.planning');
+  function walkPlanning(dir, prefix) {
+    for (const entry of listDir(dir)) {
+      const full = path.join(dir, entry.name);
+      const rel  = path.join(prefix, entry.name);
+      if (entry.isDirectory()) {
+        walkPlanning(full, rel);
+      } else if (entry.isFile() && entry.name.endsWith('.md')) {
+        state.planningFiles.push({ path: rel, name: entry.name });
+      }
+    }
+  }
+  if (fs.existsSync(planningDir)) walkPlanning(planningDir, '');
+
+  return state;
+}
+
+module.exports = { scanState, safeReadText, safeReadJson, listDir, parseSimpleYaml };

package/rihal/agents/rihal-ui-designer.md

@@ -1,6 +0,0 @@
----
-name: rihal-ui-designer
-description: Alias for rihal-ux-designer. Use that agent type instead.
----
-
-This agent is an alias for `rihal-ux-designer`. Spawn `rihal-ux-designer` directly.

package/rihal/skills/core/rihal-advanced-elicitation/rihal-advanced-elicitation/SKILL.md

@@ -1,148 +0,0 @@
----
-name: rihal-advanced-elicitation
-description: 'Push the LLM to reconsider, refine, and improve its recent output. Use when user asks for deeper critique or mentions a known deeper critique method, e.g. socratic, first principles, pre-mortem, red team.'
----
-
-# Advanced Elicitation
-
-**Goal:** Push the LLM to reconsider, refine, and improve its recent output.
-
----
-
-## CRITICAL LLM INSTRUCTIONS
-
-- **MANDATORY:** Execute ALL steps in the flow section IN EXACT ORDER
-- DO NOT skip steps or change the sequence
-- HALT immediately when halt-conditions are met
-- Each action within a step is a REQUIRED action to complete that step
-- Sections outside flow (validation, output, critical-context) provide essential context - review and apply throughout execution
-- **YOU MUST ALWAYS SPEAK OUTPUT in your Agent communication style with the `communication_language`**
-
----
-
-## INTEGRATION (When Invoked Indirectly)
-
-When invoked from another prompt or process:
-
-1. Receive or review the current section content that was just generated
-2. Apply elicitation methods iteratively to enhance that specific content
-3. Return the enhanced version back when user selects 'x' to proceed and return back
-4. The enhanced content replaces the original section content in the output document
-
----
-
-## FLOW
-
-### Step 1: Method Registry Loading
-
-**Action:** Load and read `./methods.csv` and '{project-root}/.rihal/_config/agent-manifest.csv'
-
-#### CSV Structure
-
-- **category:** Method grouping (core, structural, risk, etc.)
-- **method_name:** Display name for the method
-- **description:** Rich explanation of what the method does, when to use it, and why it's valuable
-- **output_pattern:** Flexible flow guide using arrows (e.g., "analysis -> insights -> action")
-
-#### Context Analysis
-
-- Use conversation history
-- Analyze: content type, complexity, stakeholder needs, risk level, and creative potential
-
-#### Smart Selection
-
-1. Analyze context: Content type, complexity, stakeholder needs, risk level, creative potential
-2. Parse descriptions: Understand each method's purpose from the rich descriptions in CSV
-3. Select 5 methods: Choose methods that best match the context based on their descriptions
-4. Balance approach: Include mix of foundational and specialized techniques as appropriate
-
----
-
-### Step 2: Present Options and Handle Responses
-
-#### Display Format
-
-```
-**Advanced Elicitation Options**
-_If party mode is active, agents will join in._
-Choose a number (1-5), [r] to Reshuffle, [a] List All, or [x] to Proceed:
-
-1. [Method Name]
-2. [Method Name]
-3. [Method Name]
-4. [Method Name]
-5. [Method Name]
-r. Reshuffle the list with 5 new options
-a. List all methods with descriptions
-x. Proceed / No Further Actions
-```
-
-#### Response Handling
-
-**Case 1-5 (User selects a numbered method):**
-
-- Execute the selected method using its description from the CSV
-- Adapt the method's complexity and output format based on the current context
-- Apply the method creatively to the current section content being enhanced
-- Display the enhanced version showing what the method revealed or improved
-- **CRITICAL:** Ask the user if they would like to apply the changes to the doc (y/n/other) and HALT to await response.
-- **CRITICAL:** ONLY if Yes, apply the changes. IF No, discard your memory of the proposed changes. If any other reply, try best to follow the instructions given by the user.
-- **CRITICAL:** Re-present the same 1-5,r,x prompt to allow additional elicitations
-
-**Case r (Reshuffle):**
-
-- Select 5 random methods from methods.csv, present new list with same prompt format
-- When selecting, try to think and pick a diverse set of methods covering different categories and approaches, with 1 and 2 being potentially the most useful for the document or section being discovered
-
-**Case x (Proceed):**
-
-- Complete elicitation and proceed
-- Return the fully enhanced content back to the invoking skill
-- The enhanced content becomes the final version for that section
-- Signal completion back to the invoking skill to continue with next section
-
-**Case a (List All):**
-
-- List all methods with their descriptions from the CSV in a compact table
-- Allow user to select any method by name or number from the full list
-- After selection, execute the method as described in the Case 1-5 above
-
-**Case: Direct Feedback:**
-
-- Apply changes to current section content and re-present choices
-
-**Case: Multiple Numbers:**
-
-- Execute methods in sequence on the content, then re-offer choices
-
----
-
-### Step 3: Execution Guidelines
-
-- **Method execution:** Use the description from CSV to understand and apply each method
-- **Output pattern:** Use the pattern as a flexible guide (e.g., "paths -> evaluation -> selection")
-- **Dynamic adaptation:** Adjust complexity based on content needs (simple to sophisticated)
-- **Creative application:** Interpret methods flexibly based on context while maintaining pattern consistency
-- Focus on actionable insights
-- **Stay relevant:** Tie elicitation to specific content being analyzed (the current section from the document being created unless user indicates otherwise)
-- **Identify personas:** For single or multi-persona methods, clearly identify viewpoints, and use party members if available in memory already
-- **Critical loop behavior:** Always re-offer the 1-5,r,a,x choices after each method execution
-- Continue until user selects 'x' to proceed with enhanced content, confirm or ask the user what should be accepted from the session
-- Each method application builds upon previous enhancements
-- **Content preservation:** Track all enhancements made during elicitation
-- **Iterative enhancement:** Each selected method (1-5) should:
-  1. Apply to the current enhanced version of the content
-  2. Show the improvements made
-  3. Return to the prompt for additional elicitations or completion
-
-## Output Format
-
-- Method-guided elicitation session (5 Whys, JTBD, pre-mortem, etc. from `methods.csv`)
-- Captured answers structured for downstream PRD/roadmap use
-- No method imposed without user consent — pick based on question shape
-
-## Examples
-
-### Happy Path
-**Input:** "Help me think through whether to rewrite auth"
-**Expected:** Picks pre-mortem + 5 Whys from methods.csv, runs the session, surfaces hidden assumptions.

package/rihal/skills/core/rihal-advanced-elicitation/rihal-advanced-elicitation/methods.csv

@@ -1,51 +0,0 @@
-num,category,method_name,description,output_pattern
-1,collaboration,Stakeholder Round Table,Convene multiple personas to contribute diverse perspectives - essential for requirements gathering and finding balanced solutions across competing interests,perspectives → synthesis → alignment
-2,collaboration,Expert Panel Review,Assemble domain experts for deep specialized analysis - ideal when technical depth and peer review quality are needed,expert views → consensus → recommendations
-3,collaboration,Debate Club Showdown,Two personas argue opposing positions while a moderator scores points - great for exploring controversial decisions and finding middle ground,thesis → antithesis → synthesis
-4,collaboration,User Persona Focus Group,Gather your product's user personas to react to proposals and share frustrations - essential for validating features and discovering unmet needs,reactions → concerns → priorities
-5,collaboration,Time Traveler Council,Past-you and future-you advise present-you on decisions - powerful for gaining perspective on long-term consequences vs short-term pressures,past wisdom → present choice → future impact
-6,collaboration,Cross-Functional War Room,Product manager + engineer + designer tackle a problem together - reveals trade-offs between feasibility desirability and viability,constraints → trade-offs → balanced solution
-7,collaboration,Mentor and Apprentice,Senior expert teaches junior while junior asks naive questions - surfaces hidden assumptions through teaching,explanation → questions → deeper understanding
-8,collaboration,Good Cop Bad Cop,Supportive persona and critical persona alternate - finds both strengths to build on and weaknesses to address,encouragement → criticism → balanced view
-9,collaboration,Improv Yes-And,Multiple personas build on each other's ideas without blocking - generates unexpected creative directions through collaborative building,idea → build → build → surprising result
-10,collaboration,Customer Support Theater,Angry customer and support rep roleplay to find pain points - reveals real user frustrations and service gaps,complaint → investigation → resolution → prevention
-11,advanced,Tree of Thoughts,Explore multiple reasoning paths simultaneously then evaluate and select the best - perfect for complex problems with multiple valid approaches,paths → evaluation → selection
-12,advanced,Graph of Thoughts,Model reasoning as an interconnected network of ideas to reveal hidden relationships - ideal for systems thinking and discovering emergent patterns,nodes → connections → patterns
-13,advanced,Thread of Thought,Maintain coherent reasoning across long contexts by weaving a continuous narrative thread - essential for RAG systems and maintaining consistency,context → thread → synthesis
-14,advanced,Self-Consistency Validation,Generate multiple independent approaches then compare for consistency - crucial for high-stakes decisions where verification matters,approaches → comparison → consensus
-15,advanced,Meta-Prompting Analysis,Step back to analyze the approach structure and methodology itself - valuable for optimizing prompts and improving problem-solving,current → analysis → optimization
-16,advanced,Reasoning via Planning,Build a reasoning tree guided by world models and goal states - excellent for strategic planning and sequential decision-making,model → planning → strategy
-17,competitive,Red Team vs Blue Team,Adversarial attack-defend analysis to find vulnerabilities - critical for security testing and building robust solutions,defense → attack → hardening
-18,competitive,Shark Tank Pitch,Entrepreneur pitches to skeptical investors who poke holes - stress-tests business viability and forces clarity on value proposition,pitch → challenges → refinement
-19,competitive,Code Review Gauntlet,Senior devs with different philosophies review the same code - surfaces style debates and finds consensus on best practices,reviews → debates → standards
-20,technical,Architecture Decision Records,Multiple architect personas propose and debate architectural choices with explicit trade-offs - ensures decisions are well-reasoned and documented,options → trade-offs → decision → rationale
-21,technical,Rubber Duck Debugging Evolved,Explain your code to progressively more technical ducks until you find the bug - forces clarity at multiple abstraction levels,simple → detailed → technical → aha
-22,technical,Algorithm Olympics,Multiple approaches compete on the same problem with benchmarks - finds optimal solution through direct comparison,implementations → benchmarks → winner
-23,technical,Security Audit Personas,Hacker + defender + auditor examine system from different threat models - comprehensive security review from multiple angles,vulnerabilities → defenses → compliance
-24,technical,Performance Profiler Panel,Database expert + frontend specialist + DevOps engineer diagnose slowness - finds bottlenecks across the full stack,symptoms → analysis → optimizations
-25,creative,SCAMPER Method,Apply seven creativity lenses (Substitute/Combine/Adapt/Modify/Put/Eliminate/Reverse) - systematic ideation for product innovation,S→C→A→M→P→E→R
-26,creative,Reverse Engineering,Work backwards from desired outcome to find implementation path - powerful for goal achievement and understanding endpoints,end state → steps backward → path forward
-27,creative,What If Scenarios,Explore alternative realities to understand possibilities and implications - valuable for contingency planning and exploration,scenarios → implications → insights
-28,creative,Random Input Stimulus,Inject unrelated concepts to spark unexpected connections - breaks creative blocks through forced lateral thinking,random word → associations → novel ideas
-29,creative,Exquisite Corpse Brainstorm,Each persona adds to the idea seeing only the previous contribution - generates surprising combinations through constrained collaboration,contribution → handoff → contribution → surprise
-30,creative,Genre Mashup,Combine two unrelated domains to find fresh approaches - innovation through unexpected cross-pollination,domain A + domain B → hybrid insights
-31,research,Literature Review Personas,Optimist researcher + skeptic researcher + synthesizer review sources - balanced assessment of evidence quality,sources → critiques → synthesis
-32,research,Thesis Defense Simulation,Student defends hypothesis against committee with different concerns - stress-tests research methodology and conclusions,thesis → challenges → defense → refinements
-33,research,Comparative Analysis Matrix,Multiple analysts evaluate options against weighted criteria - structured decision-making with explicit scoring,options → criteria → scores → recommendation
-34,risk,Pre-mortem Analysis,Imagine future failure then work backwards to prevent it - powerful technique for risk mitigation before major launches,failure scenario → causes → prevention
-35,risk,Failure Mode Analysis,Systematically explore how each component could fail - critical for reliability engineering and safety-critical systems,components → failures → prevention
-36,risk,Challenge from Critical Perspective,Play devil's advocate to stress-test ideas and find weaknesses - essential for overcoming groupthink,assumptions → challenges → strengthening
-37,risk,Identify Potential Risks,Brainstorm what could go wrong across all categories - fundamental for project planning and deployment preparation,categories → risks → mitigations
-38,risk,Chaos Monkey Scenarios,Deliberately break things to test resilience and recovery - ensures systems handle failures gracefully,break → observe → harden
-39,core,First Principles Analysis,Strip away assumptions to rebuild from fundamental truths - breakthrough technique for innovation and solving impossible problems,assumptions → truths → new approach
-40,core,5 Whys Deep Dive,Repeatedly ask why to drill down to root causes - simple but powerful for understanding failures,why chain → root cause → solution
-41,core,Socratic Questioning,Use targeted questions to reveal hidden assumptions and guide discovery - excellent for teaching and self-discovery,questions → revelations → understanding
-42,core,Critique and Refine,Systematic review to identify strengths and weaknesses then improve - standard quality check for drafts,strengths/weaknesses → improvements → refined
-43,core,Explain Reasoning,Walk through step-by-step thinking to show how conclusions were reached - crucial for transparency,steps → logic → conclusion
-44,core,Expand or Contract for Audience,Dynamically adjust detail level and technical depth for target audience - matches content to reader capabilities,audience → adjustments → refined content
-45,learning,Feynman Technique,Explain complex concepts simply as if teaching a child - the ultimate test of true understanding,complex → simple → gaps → mastery
-46,learning,Active Recall Testing,Test understanding without references to verify true knowledge - essential for identifying gaps,test → gaps → reinforcement
-47,philosophical,Occam's Razor Application,Find the simplest sufficient explanation by eliminating unnecessary complexity - essential for debugging,options → simplification → selection
-48,philosophical,Trolley Problem Variations,Explore ethical trade-offs through moral dilemmas - valuable for understanding values and difficult decisions,dilemma → analysis → decision
-49,retrospective,Hindsight Reflection,Imagine looking back from the future to gain perspective - powerful for project reviews,future view → insights → application
-50,retrospective,Lessons Learned Extraction,Systematically identify key takeaways and actionable improvements - essential for continuous improvement,experience → lessons → actions

package/rihal/skills/core/rihal-shard-doc/rihal-shard-doc/SKILL.md

@@ -1,122 +0,0 @@
----
-name: rihal-shard-doc
-description: 'Splits large markdown documents into smaller, organized files based on level 2 (default) sections. Use if the user says perform shard document'
----
-
-# Shard Document
-
-**Goal:** Split large markdown documents into smaller, organized files based on level 2 sections using `npx @kayvan/markdown-tree-parser`.
-
-## CRITICAL RULES
-
-- MANDATORY: Execute ALL steps in the EXECUTION section IN EXACT ORDER
-- DO NOT skip steps or change the sequence
-- HALT immediately when halt-conditions are met
-- Each action within a step is a REQUIRED action to complete that step
-
-## EXECUTION
-
-### Step 1: Get Source Document
-
-- Ask user for the source document path if not provided already
-- Verify file exists and is accessible
-- Verify file is markdown format (.md extension)
-- If file not found or not markdown: HALT with error message
-
-### Step 2: Get Destination Folder
-
-- Determine default destination: same location as source file, folder named after source file without .md extension
-  - Example: `/path/to/architecture.md` --> `/path/to/architecture/`
-- Ask user for the destination folder path (`[y]` to confirm use of default: `[suggested-path]`, else enter a new path)
-- If user accepts default: use the suggested destination path
-- If user provides custom path: use the custom destination path
-- Verify destination folder exists or can be created
-- Check write permissions for destination
-- If permission denied: HALT with error message
-
-### Step 3: Execute Sharding
-
-- Inform user that sharding is beginning
-- Execute command: `npx @kayvan/markdown-tree-parser explode [source-document] [destination-folder]`
-- Capture command output and any errors
-- If command fails: HALT and display error to user
-
-### Step 4: Verify Output
-
-- Check that destination folder contains sharded files
-- Verify index.md was created in destination folder
-- Count the number of files created
-- If no files created: HALT with error message
-
-### Step 5: Report Completion
-
-- Display completion report to user including:
-  - Source document path and name
-  - Destination folder path
-  - Number of section files created
-  - Confirmation that index.md was created
-  - Any tool output or warnings
-- Inform user that sharding completed successfully
-
-### Step 6: Handle Original Document
-
-> **Critical:** Keeping both the original and sharded versions defeats the purpose of sharding and can cause confusion.
-
-Present user with options for the original document:
-
-> What would you like to do with the original document `[source-document-name]`?
->
-> Options:
-> - `[d]` Delete - Remove the original (recommended - shards can always be recombined)
-> - `[m]` Move to archive - Move original to a backup/archive location
-> - `[k]` Keep - Leave original in place (NOT recommended - defeats sharding purpose)
->
-> Your choice (d/m/k):
-
-#### If user selects `d` (delete)
-
-- Delete the original source document file
-- Confirm deletion to user: "Original document deleted: [source-document-path]"
-- Note: The document can be reconstructed from shards by concatenating all section files in order
-
-#### If user selects `m` (move)
-
-- Determine default archive location: same directory as source, in an `archive` subfolder
-  - Example: `/path/to/architecture.md` --> `/path/to/archive/architecture.md`
-- Ask: Archive location (`[y]` to use default: `[default-archive-path]`, or provide custom path)
-- If user accepts default: use default archive path
-- If user provides custom path: use custom archive path
-- Create archive directory if it does not exist
-- Move original document to archive location
-- Confirm move to user: "Original document moved to: [archive-path]"
-
-#### If user selects `k` (keep)
-
-- Display warning to user:
-  - Keeping both original and sharded versions is NOT recommended
-  - The discover_inputs protocol may load the wrong version
-  - Updates to one will not reflect in the other
-  - Duplicate content taking up space
-  - Consider deleting or archiving the original document
-- Confirm user choice: "Original document kept at: [source-document-path]"
-
-## HALT CONDITIONS
-
-- HALT if npx command fails or produces no output files
-
-## Output Format
-
-- Original doc preserved as index (TOC linking to shards)
-- Shards at `{doc_stem}/{shard-slug}.md` under the parent's dir
-- Each shard stays under 500 lines
-- Cross-shard references via relative markdown links
-
-## Examples
-
-### Happy Path
-**Input:** "Shard this 1500-line PRD into sections"
-**Expected:** PRD.md becomes index; sections split into PRD/{section-slug}.md files. Links preserved.
-
-### Negative Test
-**Input:** Shard a document under 500 lines
-**Expected:** Refuse — too small to benefit from sharding. Suggest alternative.

package/rihal/workflows/config.md

@@ -1,105 +0,0 @@
-# Workflow: rihal:config
-
-<purpose>
-View or interactively edit Rihal project configuration (language, mode, model profile, branching strategy).
-</purpose>
-
-## Step 0 — Usage check
-
-If `$ARGUMENTS` is empty or contains only `--help` or `-h`:
-
-```
-/rihal:config [show | set <key> <value>]
-```
-
-**Examples:**
-```
-/rihal:config show
-/rihal:config set communication_language Arabic
-/rihal:config set mode yolo
-```
-
-If no arguments provided, enter interactive mode (Step 2).
-
-## Step 1 — Parse input
-
-- If first argument is `show` (or no args): proceed to Step 1.5 (display current config)
-- If first argument is `set`: proceed to Step 2 (update value)
-- Otherwise: treat as interactive mode
-
-## Step 1.5 — Display current config
-
-Read `.rihal/config.yaml` and print in formatted table:
-
-```
-Current Rihal Configuration:
-  user_name              : {value}
-  project_name           : {value}
-  communication_language : {value}
-  mode                   : {value}
-  model_profile          : {value}
-  branching_strategy     : {value}
-```
-
-STOP — do not proceed further.
-
-## Step 2 — Interactive or set mode
-
-### If `set <key> <value>`:
-
-Validate key is one of: `communication_language`, `mode`, `model_profile`, `branching_strategy`.
-
-If invalid, print error and STOP:
-```
-Unknown config key: {key}
-Allowed keys: communication_language, mode, model_profile, branching_strategy
-```
-
-Call:
-```bash
-node .rihal/bin/rihal-tools.cjs config set --key {key} --value {value}
-```
-
-Print success:
-```
-✓ Updated: {key} = {value}
-```
-
-STOP.
-
-### If no arguments (interactive mode):
-
-Use AskUserQuestion for each setting:
-
-1. Ask: "Communication language?" (show current value)
-   - Options: English, Arabic, Spanish, French, Chinese, etc.
-2. Ask: "Mode?" (guided or yolo?)
-   - guided = confirm at gates
-   - yolo = autonomous execution
-3. Ask: "Model profile?" (balanced, fast, or thorough?)
-4. Ask: "Branching strategy?" (none, auto-branch, feature-branch, trunk-based?)
-
-After each selection, call the config set command from Step 2.
-
-Print summary:
-```
-✓ Configuration updated:
-  communication_language : {value}
-  mode                   : {value}
-  model_profile          : {value}
-  branching_strategy     : {value}
-```
-
-STOP.
-
-## Success Criteria
-
-- [ ] Current config displayed or updated successfully
-- [ ] No validation errors
-- [ ] .rihal/config.yaml reflects changes
-
-## On Error
-
-- **Invalid key:** print allowed keys and stop.
-- **.rihal/config.yaml missing:** print "No config found. Run /rihal:init first."
-- **rihal-tools.cjs missing:** tell user to run `rihal-code install-v2`.