@hanzlaa/rcode 3.6.7 → 3.6.14

package/cli/generate-command-skills.cjs

@@ -40,18 +40,11 @@ const path = require('path');
  * functional). Power users running niche commands like /rihal-prfaq or
  * /rihal-ui-phase still get them — they just don't show up in the sidebar.
  */
-const SIDEBAR_COMMANDS = new Set([
-  // Navigation & status (the daily check-in)
-  'do', 'status', 'next',
-  // Core lifecycle (the workflow loop)
-  'plan', 'execute', 'ship',
-  // Strategic
-  'council',
-  // Quality gate
-  'audit', 'verify-phase',
-  // Utility
-  'note',
-]);
+// Empty — sidebar stubs with user-invocable:false block direct /rihal-* invocation
+// in Claude Code 2.x. Commands in .claude/commands/ already appear in slash autocomplete.
+// The VS Code sidebar also shows commands directly in CC 2.x, so stubs are redundant.
+// Issue #710: sidebar stubs caused "can only be invoked by Claude" error for users.
+const SIDEBAR_COMMANDS = new Set([]);
 
 function parseFrontmatter(text) {
   if (!text.startsWith('---\n')) return {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hanzlaa/rcode",
-  "version": "3.6.7",
+  "version": "3.6.14",
   "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/rihal/bin/rihal-hooks.cjs

@@ -321,69 +321,184 @@ async function bashGuard() {
 }
 
 /**
- * pre-compact: Refresh HANDOFF.json before context compaction (#743).
+ * pre-compact: Capture rihal session state before context compaction.
  *
- * Triggered by the PreCompact hook. Reads .rihal/state.json from the current
- * working directory and, if a phase is active, writes a HANDOFF.json pointer
- * so a post-compaction agent can resume cleanly. No-op when no phase is
- * active. Never blocks compaction.
+ * Triggered by the PreCompact hook. Enriched version (#743 + enhancement):
+ *   1. Reads .rihal/state.json + .planning/STATE.md + active SPRINT.md
+ *   2. Collects recent git commits and in-progress task checkboxes
+ *   3. Writes enriched .rihal/HANDOFF.json (machine-readable resume file)
+ *   4. Writes .rihal/.continue-here.md (paste-ready resume prompt)
+ *   5. Outputs { systemMessage } so Claude sees context immediately after
+ *      compaction — enabling /rihal-resume-work to restore full context.
+ *
+ * Never blocks compaction — any error exits 1 (non-blocking per spec).
  */
 async function preCompact() {
   try {
     const path = require('path');
+    const { execSync } = require('child_process');
     await readInputJson(); // drain the PreCompact event payload
 
     const cwd = process.cwd();
+
+    // ── 1. Load state.json ──────────────────────────────────────────────
     const statePath = path.join(cwd, '.rihal', 'state.json');
-    if (!fs.existsSync(statePath)) {
-      process.exit(0);
+    let state = null;
+    if (fs.existsSync(statePath)) {
+      try { state = JSON.parse(fs.readFileSync(statePath, 'utf8')); } catch {}
     }
 
-    let state;
-    try {
-      state = JSON.parse(fs.readFileSync(statePath, 'utf8'));
-    } catch {
-      process.exit(0);
+    // ── 2. Determine active phase ────────────────────────────────────────
+    const phases = Array.isArray(state?.phases) ? state.phases : [];
+    const executing = phases.find((p) => p && p.status === 'executing');
+    const matched = phases.find(
+      (p) => p && (p.name === state?.current_phase || p.number === state?.current_phase)
+    );
+    const activePhase = executing || matched || null;
+    const phaseLabel = activePhase
+      ? (activePhase.number || activePhase.name || state?.current_phase)
+      : (state?.current_phase || null);
+
+    // ── 3. Read active SPRINT.md (incomplete tasks) ──────────────────────
+    const incompleteTasks = [];
+    const completedCount = { done: 0, total: 0 };
+    const planningBase = path.join(cwd, '.planning', 'phases');
+    if (phaseLabel && fs.existsSync(planningBase)) {
+      try {
+        const phaseDirs = fs.readdirSync(planningBase)
+          .filter(d => d.startsWith(String(phaseLabel)));
+        for (const pd of phaseDirs) {
+          const pdPath = path.join(planningBase, pd);
+          if (!fs.statSync(pdPath).isDirectory()) continue;
+          const sprintFiles = fs.readdirSync(pdPath)
+            .filter(f => f.endsWith('-SPRINT.md'))
+            .sort()
+            .reverse(); // most recent first
+          if (sprintFiles.length === 0) continue;
+          const sprintText = fs.readFileSync(path.join(pdPath, sprintFiles[0]), 'utf8');
+          for (const line of sprintText.split('\n')) {
+            const done = /^\s*-\s*\[x\]/i.test(line);
+            const pending = /^\s*-\s*\[ \]/.test(line);
+            if (done || pending) completedCount.total++;
+            if (done) completedCount.done++;
+            if (pending) {
+              const task = line.replace(/^\s*-\s*\[ \]\s*/, '').trim();
+              if (task) incompleteTasks.push(task);
+            }
+          }
+          break; // use first matching phase dir only
+        }
+      } catch {}
     }
 
-    const phases = Array.isArray(state.phases) ? state.phases : [];
-    const hasActivePhase =
-      !!state.current_phase &&
-      phases.length > 0 &&
-      phases.some(
-        (p) =>
-          p &&
-          (p.status === 'executing' ||
-            p.name === state.current_phase ||
-            p.number === state.current_phase)
-      );
+    // ── 4. Recent git commits ────────────────────────────────────────────
+    let recentCommits = [];
+    try {
+      const log = execSync('git log --oneline -5 --no-decorate 2>/dev/null', {
+        cwd, encoding: 'utf8', timeout: 3000,
+      }).trim();
+      recentCommits = log ? log.split('\n').filter(Boolean) : [];
+    } catch {}
 
-    if (!hasActivePhase) {
-      process.exit(0);
+    // ── 5. Read milestone / roadmap headline ────────────────────────────
+    let milestoneHint = state?.milestone || null;
+    if (!milestoneHint) {
+      for (const rp of ['.planning/ROADMAP.md', '.planning/milestones/ROADMAP.md']) {
+        const full = path.join(cwd, rp);
+        if (!fs.existsSync(full)) continue;
+        const m = fs.readFileSync(full, 'utf8').match(/^##\s+Milestone\s+(M\d+[^\n]*)/m);
+        if (m) { milestoneHint = m[1].trim(); break; }
+      }
     }
 
-    const executing = phases.find((p) => p && p.status === 'executing');
-    const matched = phases.find(
-      (p) => p && (p.name === state.current_phase || p.number === state.current_phase)
-    );
-    const activePhase = executing || matched;
-    const phaseLabel = activePhase
-      ? activePhase.number || activePhase.name || state.current_phase
-      : state.current_phase;
+    // ── 6. Read last 3 decisions from STATE.md ───────────────────────────
+    let recentDecisions = [];
+    const stateFile = path.join(cwd, '.planning', 'STATE.md');
+    if (fs.existsSync(stateFile)) {
+      try {
+        const stateText = fs.readFileSync(stateFile, 'utf8');
+        const decSection = stateText.match(/##\s+(?:Recent\s+)?Decisions[\s\S]*?(?=\n##|\Z)/i);
+        if (decSection) {
+          recentDecisions = decSection[0]
+            .split('\n')
+            .filter(l => /^\s*[-*]/.test(l))
+            .slice(0, 3)
+            .map(l => l.replace(/^\s*[-*]\s*/, '').trim())
+            .filter(Boolean);
+        }
+      } catch {}
+    }
 
+    // ── 7. Build enriched HANDOFF.json ───────────────────────────────────
     const handoff = {
       generated_at: new Date().toISOString(),
       reason: 'pre-compact',
       phase: phaseLabel,
-      current_plan: state.current_plan ?? null,
-      current_sprint: state.current_sprint ?? null,
+      milestone: milestoneHint,
+      current_plan: state?.current_plan ?? null,
+      current_sprint: state?.current_sprint ?? null,
+      progress: completedCount.total > 0
+        ? `${completedCount.done}/${completedCount.total} tasks done`
+        : null,
+      incomplete_tasks: incompleteTasks.slice(0, 10),
+      recent_commits: recentCommits,
+      recent_decisions: recentDecisions,
     };
 
-    const handoffPath = path.join(cwd, 'HANDOFF.json');
-    const tmpPath = handoffPath + '.tmp';
-    fs.writeFileSync(tmpPath, JSON.stringify(handoff, null, 2) + '\n');
-    fs.renameSync(tmpPath, handoffPath);
+    const rihalDir = path.join(cwd, '.rihal');
+    if (!fs.existsSync(rihalDir)) {
+      process.exit(0); // not a rihal project
+    }
+
+    const handoffPath = path.join(rihalDir, 'HANDOFF.json');
+    fs.writeFileSync(handoffPath + '.tmp', JSON.stringify(handoff, null, 2) + '\n');
+    fs.renameSync(handoffPath + '.tmp', handoffPath);
+
+    // ── 8. Write .continue-here.md (paste-ready resume prompt) ───────────
+    const resumeLines = [
+      '# Rihal Session Resume',
+      '',
+      `**Compacted:** ${handoff.generated_at}`,
+      phaseLabel ? `**Phase:** ${phaseLabel}` : null,
+      milestoneHint ? `**Milestone:** ${milestoneHint}` : null,
+      handoff.progress ? `**Progress:** ${handoff.progress}` : null,
+      '',
+    ].filter(l => l !== null);
+
+    if (incompleteTasks.length > 0) {
+      resumeLines.push('**Next tasks:**');
+      incompleteTasks.slice(0, 5).forEach(t => resumeLines.push(`- [ ] ${t}`));
+      resumeLines.push('');
+    }
+    if (recentCommits.length > 0) {
+      resumeLines.push('**Recent commits:**');
+      recentCommits.forEach(c => resumeLines.push(`- ${c}`));
+      resumeLines.push('');
+    }
+    if (recentDecisions.length > 0) {
+      resumeLines.push('**Recent decisions:**');
+      recentDecisions.forEach(d => resumeLines.push(`- ${d}`));
+      resumeLines.push('');
+    }
+    resumeLines.push('---');
+    resumeLines.push('Run `/rihal-resume-work` to restore full project context.');
+
+    fs.writeFileSync(
+      path.join(rihalDir, '.continue-here.md'),
+      resumeLines.join('\n') + '\n'
+    );
+
+    // ── 9. Emit systemMessage for Claude post-compaction ─────────────────
+    const msgParts = ['**Rihal context compacted.**'];
+    if (phaseLabel) msgParts.push(`Active phase: **${phaseLabel}**`);
+    if (milestoneHint) msgParts.push(`Milestone: ${milestoneHint}`);
+    if (handoff.progress) msgParts.push(`Progress: ${handoff.progress}`);
+    if (incompleteTasks.length > 0) {
+      msgParts.push(`Next task: ${incompleteTasks[0]}`);
+    }
+    msgParts.push('Run `/rihal-resume-work` to restore full context, or `/clear` then paste `.rihal/.continue-here.md`.');
 
+    process.stdout.write(JSON.stringify({ systemMessage: msgParts.join(' | ') }) + '\n');
     process.exit(0);
   } catch (err) {
     console.error(`Hook error: ${err.message}`);

package/rihal/bin/rihal-tools.cjs

@@ -6070,7 +6070,7 @@ function cmdProgress(args) {
     return insights;
   }
 
-  function deriveRoutes(state, roadmapPhases, diskByNum) {
+  function deriveRoutes(state, roadmapPhases, diskByNum, insights) {
     const routes = [];
     const statePhases = (state && (state.state?.phases || state.phases)) || [];
 
@@ -6092,26 +6092,18 @@ function cmdProgress(args) {
     }).slice(0, 3);
     for (const p of pendingExec) {
       const k = phaseKey(p);
-      routes.push({
-        letter: 'A',
-        label: `Execute phase ${k} — unfinished plans`,
-        command: `/rihal-execute ${k}`,
-      });
+      routes.push({ letter: 'A', label: '', command: `/rihal-execute ${k}` });
     }
 
     // Route B — phases with research but no plans
     const researchOnly = Object.entries(diskByNum)
       .filter(([num, d]) => d.has_research && d.plan_count === 0)
       .slice(0, 3);
-    for (const [num, d] of researchOnly) {
-      routes.push({
-        letter: 'B',
-        label: `Plan phase ${num} — researched, awaiting plan`,
-        command: `/rihal-plan-phase ${num}`,
-      });
+    for (const [num] of researchOnly) {
+      routes.push({ letter: 'B', label: '', command: `/rihal-plan ${num}` });
     }
 
-    // Route B' — in-progress phases without plans (the user is actively working but no SPRINT.md exists yet)
+    // Route B' — in-progress phases without plans
     const inProgressNoPlan = statePhases
       .filter(p => (p.status === 'in_progress' || p.status === 'in-progress'))
       .filter(p => {
@@ -6121,24 +6113,32 @@ function cmdProgress(args) {
       .slice(0, 2);
     for (const p of inProgressNoPlan) {
       const k = phaseKey(p);
-      routes.push({
-        letter: 'B',
-        label: `Plan phase ${k} — in progress without SPRINT.md`,
-        command: `/rihal-plan ${k}`,
-      });
+      routes.push({ letter: 'B', label: '', command: `/rihal-plan ${k}` });
     }
 
     // Route C — close out milestone if everything seems done
     const allDone = statePhases.length > 0 && statePhases.every(p => p.status === 'complete' || p.completed);
     if (allDone) {
-      routes.push({ letter: 'C', label: 'Audit current milestone', command: '/rihal-audit-milestone' });
-      routes.push({ letter: 'C', label: 'Complete current milestone', command: '/rihal-complete-milestone' });
+      // Count unverified phases (complete but no VERIFICATION.md on disk)
+      const unverifiedCount = statePhases.filter(p => {
+        const disk = diskByNum[phaseKey(p)];
+        return (p.status === 'complete' || p.completed) && disk && !disk.has_verification;
+      }).length;
+      const hasDrift = (insights || []).some(i => i.kind === 'roadmap-drift' || (i.message && i.message.includes('ROADMAP')));
+      const auditArgs = [];
+      if (unverifiedCount > 0) auditArgs.push(String(unverifiedCount));
+      if (hasDrift) auditArgs.push('--fix-drift');
+      const auditCmd = auditArgs.length > 0
+        ? `/rihal-audit-milestone ${auditArgs.join(' ')}`
+        : '/rihal-audit-milestone';
+      routes.push({ letter: 'C', label: '', command: auditCmd });
+      routes.push({ letter: 'C', label: '', command: '/rihal-complete-milestone' });
     }
 
     // Fallback — nothing obvious: offer status
     if (routes.length === 0) {
-      routes.push({ letter: 'A', label: 'Check progress detail', command: '/rihal-progress' });
-      routes.push({ letter: 'B', label: 'Start a council on what to do next', command: '/rihal-council' });
+      routes.push({ letter: 'A', label: '', command: '/rihal-progress' });
+      routes.push({ letter: 'B', label: '', command: '/rihal-council' });
     }
 
     return routes;
@@ -6208,14 +6208,15 @@ function cmdProgress(args) {
   }
 
   if (sub === 'routes') {
-    return { ok: true, routes: deriveRoutes(state, roadmapPhases, diskByNum) };
+    const routeInsights = detectInsights(state, roadmapPhases, diskByNum);
+    return { ok: true, routes: deriveRoutes(state, roadmapPhases, diskByNum, routeInsights) };
   }
 
   // sub === 'init' (default) — full snapshot
   const currentPhase = state && state.current_phase;
   const insights = detectInsights(state, roadmapPhases, diskByNum);
   enforceStrictGate(insights);
-  const routes = deriveRoutes(state, roadmapPhases, diskByNum);
+  const routes = deriveRoutes(state, roadmapPhases, diskByNum, insights);
   const { weighted: weightedCompleted, pct: weightedPct } = computeWeightedProgress(statePhases, diskByNum);
 
   return {

package/rihal/commands/execute-milestone.md

@@ -10,9 +10,9 @@ Execute all phases in the current milestone in dependency order, with verify gat
 </objective>
 
 <execution_context>
-@.rihal/workflows/execute-milestone.md
+@rihal/workflows/execute-milestone.md
 </execution_context>
 
 <process>
-Execute the execute-milestone workflow from @.rihal/workflows/execute-milestone.md end-to-end.
+Execute the execute-milestone workflow from @rihal/workflows/execute-milestone.md end-to-end.
 </process>

package/rihal/commands/plan-milestone.md

@@ -10,9 +10,9 @@ Plan all phases for a milestone using parallel dependency-wave execution. Group
 </objective>
 
 <execution_context>
-@.rihal/workflows/plan-milestone.md
+@rihal/workflows/plan-milestone.md
 </execution_context>
 
 <process>
-Execute the plan-milestone workflow from @.rihal/workflows/plan-milestone.md end-to-end.
+Execute the plan-milestone workflow from @rihal/workflows/plan-milestone.md end-to-end.
 </process>

package/rihal/commands/scaffold-milestone.md

@@ -10,9 +10,9 @@ Execute scaffold-milestone workflow
 </objective>
 
 <execution_context>
-@.rihal/workflows/scaffold-milestone.md
+@rihal/workflows/scaffold-milestone.md
 </execution_context>
 
 <process>
-Execute the scaffold-milestone workflow from @.rihal/workflows/scaffold-milestone.md end-to-end.
+Execute the scaffold-milestone workflow from @rihal/workflows/scaffold-milestone.md end-to-end.
 </process>

package/rihal/references/continuation-format.md

@@ -52,7 +52,6 @@ Standard format for presenting next steps after completing a command or workflow
 
 **Also available:**
 - Review plan before executing
-- `/rihal-list-phase-assumptions 2` — check assumptions
 
 ---
 ```
@@ -91,7 +90,7 @@ Add note that this is the last plan and what comes after:
 
 **Phase 2: Authentication** — JWT login flow with refresh tokens
 
-`/rihal-plan-phase 2`
+`/rihal-plan 2`
 
 <sub>`/clear` first → fresh context window</sub>
 
@@ -120,7 +119,7 @@ Show completion status before next action:
 
 **Phase 3: Core Features** — User dashboard, settings, and data export
 
-`/rihal-plan-phase 3`
+`/rihal-plan 3`
 
 <sub>`/clear` first → fresh context window</sub>
 
@@ -145,7 +144,7 @@ When there's no clear primary action:
 
 **Phase 3: Core Features** — User dashboard, settings, and data export
 
-**To plan directly:** `/rihal-plan-phase 3`
+**To plan directly:** `/rihal-plan 3`
 
 **To discuss context first:** `/rihal-discuss-phase 3`
 
@@ -222,7 +221,7 @@ User has no idea what 02-03 is about.
 ### Don't: Missing /clear explanation
 
 ```
-`/rihal-plan-phase 3`
+`/rihal-plan 3`
 
 Run /clear first.
 ```
@@ -242,7 +241,7 @@ Sounds like an afterthought. Use "Also available:" instead.
 
 ```
 ```
-/rihal-plan-phase 3
+/rihal-plan 3
 ```
 ```
 

package/rihal/references/research-synthesis-playbook.md

@@ -70,7 +70,7 @@ This is the most important section. Based on combined research:
 - Which pitfalls it must avoid
 
 **Add research flags:**
-- Which phases likely need `/rihal-research` during planning?
+- Which phases likely need `/rihal-research-phase` during planning?
 - Which phases have well-documented patterns (skip research)?
 
 ## Step 5: Assess Confidence

package/rihal/skills/actions/2-plan/rihal-create-milestone/steps/step-06-phase-stubs.md

@@ -9,7 +9,7 @@ For each milestone, list the phases it contains as **stubs** (number + name + on
 ## MANDATORY RULES
 
 - 🛑 Phase numbers follow Rihal's NN convention (01, 02, ..., 99, then 999.x for parking lot).
-- 🛑 Do NOT generate plan content here. That's `/rihal-plan-phase`.
+- 🛑 Do NOT generate plan content here. That's `/rihal-plan`.
 - 🛑 Each phase has one-sentence goal, max.
 - ⏸️ HALT at menu.
 

package/rihal/skills/actions/2-plan/rihal-create-milestone/steps/step-10-complete.md

@@ -42,7 +42,7 @@ What's next?
       → /rihal-create-epics-and-stories
 
   [B] Plan the first phase in detail
-      → /rihal-plan-phase 01
+      → /rihal-plan 01
 
   [C] Review the roadmap with the team
       → /rihal-council "Is this roadmap realistic?"

package/rihal/skills/actions/4-implementation/rihal-debug/SKILL.md

@@ -44,6 +44,8 @@ If you have not completed Phase 1, you cannot propose a fix. "It seems to work"
 
 Debugging is investigation, not pattern-matching. Each iteration narrows the problem space — never widens it. The skill enforces a written hypothesis, an experiment that distinguishes "yes" from "no", and a captured observation. Random fixes are not allowed — the bug must be understood before the fix is written.
 
+## Workflow
+
 ## Phase 1 — Root Cause Investigation
 
 **BEFORE attempting ANY fix:**

package/rihal/workflows/analyze-dependencies.md

@@ -1,7 +1,7 @@
 # Workflow: rihal-analyze-dependencies
 
 <purpose>
-Analyze ROADMAP.md phases for dependency relationships before execution. Detect file overlap between phases, semantic API/data-flow dependencies, and suggest `Depends on` entries to prevent merge conflicts during parallel execution by `/rihal-manager`.
+Analyze ROADMAP.md phases for dependency relationships before execution. Detect file overlap between phases, semantic API/data-flow dependencies, and suggest `Depends on` entries to prevent merge conflicts during parallel execution.
 </purpose>
 
 
@@ -119,7 +119,7 @@ When writing:
 - Preserve all other phase content unchanged
 - Do not reorder phases
 
-After applying: "ROADMAP.md updated. Run `/rihal-manager` to execute phases in the correct order."
+After applying: "ROADMAP.md updated. Run `/rihal-execute-milestone` to execute phases in the correct order."
 
 ## Success Criteria
 
@@ -140,5 +140,5 @@ After applying: "ROADMAP.md updated. Run `/rihal-manager` to execute phases in t
 ## ▶ Next Up
 
 - **Circular deps found:** Fix dependency cycle, then re-run analysis
-- **Ready to execute:** `/rihal-execute {phase}` — run with dependency awareness
-- **Review roadmap:** `/rihal-progress` — see full project state
+- /rihal-execute {phase}
+- /rihal-progress

package/rihal/workflows/audit-fix.md

@@ -199,6 +199,6 @@ If arguments are invalid, missing files, or subagent fails:
 
 ## ▶ Next Up
 
-- **Fixes applied:** `/rihal-verify-phase {phase}` — re-verify after fixes
-- **More issues:** `/rihal-audit {phase}` — run audit again to confirm
-- **All clean:** `/rihal-progress` — check project state
+- /rihal-verify-phase {phase}
+- /rihal-audit {phase}
+- /rihal-progress

package/rihal/workflows/audit-milestone.md

@@ -4,22 +4,23 @@
 Cross-phase audit of milestone completion. Reads all SUMMARY.md files from completed phases, compares their outcomes to the original ROADMAP goals, flags gaps, and generates an audit report showing completion percentage and decision traceability.
 </purpose>
 
-## Step 0 — Usage check
+## Step 0 — Parse arguments
 
-If `$ARGUMENTS` contains only `--help` or `-h`:
+Parse `$ARGUMENTS`:
+- `--help` or `-h` → print usage and stop:
+  ```
+  /rihal-audit-milestone [<unverified-count>] [--fix-drift] [--strict] [--report]
+  ```
+- A bare integer (e.g. `28`) → `HINT_UNVERIFIED_COUNT = 28` (pre-computed by rihal-status for display; use as expected minimum in the scan)
+- `--fix-drift` → `FIX_DRIFT = true` (after audit, suggest the drift sync command)
+- `--strict` → `STRICT = true`
+- `--report` → `WRITE_REPORT = true`
 
+If `HINT_UNVERIFIED_COUNT` is set, print at the top of the audit output:
 ```
-/rihal-audit-milestone [--strict] [--report]
+ℹ Expecting ~{HINT_UNVERIFIED_COUNT} phases to verify (from rihal-status)
 ```
 
-**Examples:**
-```
-/rihal-audit-milestone
-/rihal-audit-milestone --strict --report
-```
-
-STOP — do not proceed.
-
 ## Step 1 — Locate milestone context
 
 Determine the active milestone. Check: