revise-and-resubmit-cc 2.0.0

package/README.md

@@ -0,0 +1,208 @@
+<div align="center">
+
+# REVISE & RESUBMIT (R&R)
+
+**A light-weight and powerful meta-prompting and context engineering system for automating academic revisions directly inside Claude Code.**
+
+**Solves formatting rot — the style degradation and context loss that happens when LLMs edit complex academic documents.**
+
+[![npm version](https://img.shields.io/npm/v/revise-and-resubmit-cc?style=for-the-badge&logo=npm&logoColor=white&color=CB3837)](#)
+[![License](https://img.shields.io/badge/license-MIT-blue?style=for-the-badge)](LICENSE)
+
+<br>
+
+```bash
+node bin/install.js --claude --local
+```
+
+**Works on Mac, Windows, and Linux.**
+
+<br>
+
+# Revise & Resubmit (R&R) Framework
+*An automated, agent-based academic revision ecosystem powered by Claude Code.*
+
+## What is R&R?
+When you submit an academic paper, peer reviewers often send back a Microsoft Word `.docx` file filled with dozens (or hundreds) of comments and edit suggestions. 
+
+Manually going through every comment, finding the context, researching the change, negotiating with the reviewer, and rewriting the text can take weeks. 
+
+**Revise & Resubmit (R&R)** is a custom `get-shit-done` style framework for Claude Code that automates this entire process. You simply point R&R at the `.docx` file, and a specialized team of AI "subagents" will extract the comments, edit the manuscript based on your personal writing style, research external data if needed, ask you clarifying questions, and quickly repack a finished `.docx` file ready for submission.
+
+---
+
+## How It Works: The Subagent Ecosystem (In Layman's Terms)
+
+R&R doesn't just use one massive AI that tries to do everything at once (which usually leads to the AI getting confused, skipping comments, or making things up). 
+
+Instead, it relies on a **Subagent Ecosystem**—a highly specialized team of mini-AIs where each agent has exactly one precise job. 
+
+Here is the assembly line:
+
+### 1. The Extractors & Assemblers
+*   **The Extractor:** When you run `/rnr:extract-comments`, R&R spawns a specialized python-runner agent. Its only job is to silently open your `.docx`, find every single Reviewer comment and Edit Suggestion, extract the exact paragraph they attached it to, and save them as individual files (e.g., `COMMENT_1.md`, `COMMENT_2.md`).
+*   **The Assembler:** At the very end, when you run `/rnr:assemble`, a new dedicated agent takes all the revised paragraphs and perfectly injects them back into a clean, formatted `.docx` file without messing up your citations or graphs.
+
+### 2. The Processors (The Heavy Lifters)
+When you tell R&R to get to work (`/rnr:process-comments`), it looks at the extracted files and sorts them:
+*   **Isolated Comments:** Typos or localized changes that don't affect anything else. R&R spawns one **Fresh Processor Agent** for *each* isolated comment simultaneously. 
+*   **Interlaced Comments:** If a reviewer says "move this here" in comment 4, and "delete this" in comment 5, R&R groups them. It assigns one **Dedicated Processor Agent** to handle that specific group together so the edits make sense.
+
+*Crucially, Processor Agents do NOT talk to you, and they do NOT search the internet. They only look at the comment, look at your style guide, and rewrite the text.*
+
+### 3. The Delegates (The Specialists)
+If a Processor Agent encounters a problem it can't solve by just rewriting text, it asks for help from the specialists:
+*   **The Researcher:** If the reviewer asks "Can you add a citation for this claim?", the Processor stops and spawns a **Researcher Agent**. The Researcher silently connects to your Google NotebookLM (containing all your PDFs and research), finds the exact answer, and hands it back to the Processor to write the revision.
+*   **The Clarifier:** If the reviewer leaves a vague comment like "I don't like this," the Processor stops and spawns a **Clarifier Agent**. The Clarifier will pop up in your terminal, explain the ambiguity, and chat with you to figure out what you want to do. Once you decide, the Clarifier hands your instruction back to the Processor to execute the edit.
+
+---
+
+## Getting Started
+
+### Prerequisites
+1.  You must have **Claude Code** installed.
+2.  Your terminal must be running in the folder where your manuscript `.docx` is located.
+3.  *(Highly Recommended)* Install the NotebookLM MCP tool so R&R can do automated research:
+    `claude mcp add notebooklm notebooklm-mcp-cli`
+
+### Installation
+Clone this repository to your machine. Then, in your terminal, run:
+```bash
+node /path/to/rnr/bin/install.js
+```
+This registers the R&R commands with Claude Code.
+
+### Step 1: Initialize the Project
+Navigate to the directory containing your `.docx` manuscript and run:
+```bash
+/rnr:init
+```
+This sets up the hidden environment (`.rnr/`) that allows the Subagents to run perfectly isolated scripts. It will also ask you to link a specific NotebookLM notebook so the **Researcher Agents** know where to look.
+
+### Step 2: Extract the Comments
+Extract the reviewer comments and map them to the document:
+```bash
+/rnr:extract-comments manuscript.docx "Reviewer 1"
+```
+
+### Step 3: Define Your Style
+Ensure the AI edits sound exactly like you:
+```bash
+/rnr:synthesize-style
+```
+This crawls your manuscript to map your tone, vocabulary, and sentence structures.
+
+### Step 4: Unleash the Ecosystem
+Start the automated revision factory:
+```bash
+/rnr:process-comments
+```
+Grab a coffee. The subagents will negotiate, research, and edit every comment asynchronously. If they need you, the **Clarifier** will ping you in the terminal.
+
+### Step 5: Assemble the Final Document
+Once processing is complete, repack the manuscript:
+```bash
+/rnr:assemble final_manuscript.docx
+```
+Your paper is now ready to resubmit!
+
+---
+
+### 5. Assemble Final Document
+
+```
+/rnr:assemble output_revised.docx
+```
+
+The system:
+
+1. **Validates** — Ensures all XML nodes are closed.
+2. **Injects** — Adds the drafted "Response to Reviewers" as nested comments in the document.
+3. **Packs** — Flawlessly recompiles the `.docx`.
+
+Walk away, come back to a completed revision.
+
+---
+
+## Why It Works
+
+### Lean Orchestration (Zero Context Bleeding)
+A major problem with using LLMs for full document revision is "Context Rot." If the AI reads a 50-page document and 100 comments, it will start forgetting instructions, ignoring style guides, and hallucinating facts simply because its token window is exhausted.
+
+R&R solves this with **Lean Orchestration**:
+1. **The Orchestrator is Blind:** The main AI running the `/rnr:process-comments` command is strictly forbidden from reading your manuscript or your style guide. It only coordinates the workflow. This guarantees the orchestrator never runs out of tokens and never requires you to type `/clear`.
+2. **Subagents read files natively:** When the orchestrator spawns a subagent to fix a comment, it uses a native `<files_to_read>` block to pass the *paths* to the required files (e.g., `style_skill.md`, `COMMENT_12.md`).
+3. **Fresh Context:** That subagent boots up with a completely fresh, empty context window. It uses its built-in read tools to ingest the exact style rules and the exact paragraph it needs to fix. 
+
+This strict separation guarantees that every single comment receives 100% of Claude's analytical focus, with zero context degradation, no matter how many comments your document has.
+
+### XML Prompt Formatting
+
+Every agent is structured XML optimized for Claude:
+
+```xml
+<classification type="needs_context">
+  <reasoning>The reviewer asks us to cite the 2023 review by Johnson et al. We need human input.</reasoning>
+  <prompt_for_human>Please provide the full citation and a brief summary for Johnson et al. 2023.</prompt_for_human>
+</classification>
+```
+
+Precise instructions. No guessing.
+
+### Dedicated Python Tools
+
+R&R hooks directly into Anthropic's validated `unpack.py` and `pack.py` python toolkit via `/bash`. This is how it guarantees it will not destroy your page margins or tables when modifying the `.docx` text.
+
+---
+
+## Commands
+
+### Core Workflow
+
+| Command | What it does |
+|---------|--------------|
+| `/rnr:init` | Installs the parser and assembler scripts to a `.rnr/` folder in the current directory |
+| `/rnr:extract-comments <file>` | Unpacks the `.docx` into XML and extracts Reviewer 1/2 comments |
+| `/rnr:synthesize-style` | Constructs `style_skill.md` from your writing |
+| `/rnr:process-comments` | Iterates through each comment, prompting for human context when needed |
+| `/rnr:assemble <output>` | Repacks XML into a fully valid, formatted `.docx` |
+
+### Utilities
+
+| Command | What it does |
+|---------|--------------|
+| `/rnr:help` | Show all commands and usage guide |
+| `/rnr:update` | Updates the framework and scripts to the latest version via `git pull` |
+
+### Updating from Version 1
+
+If you installed the framework before the `/rnr:update` command existed, you must manually fetch the new updates once to activate the auto-updater. Simply run:
+
+```bash
+cd rnr
+git pull origin main
+node bin/install.js --claude --global
+```
+You can now use `/rnr:update` inside Claude Code going forward.
+
+---
+
+## Security
+
+### Protecting Your Manuscript
+
+Since R&R is entirely open source and relies strictly on your local Anthropic API and Claude Code environment, your manuscript is never uploaded to third-party databases (like ChatGPT's training pipeline) beyond the standard Anthropic backend.
+
+---
+
+## License
+
+MIT License. See [LICENSE](LICENSE) for details.
+
+---
+
+<div align="center">
+
+**Claude Code is powerful. R&R makes it academic.**
+
+</div>

package/bin/install.js

@@ -0,0 +1,43 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+const args = process.argv.slice(2);
+const isGlobal = args.includes('--global') || args.includes('-g');
+
+const CLAUDE_DIR = isGlobal
+  ? path.join(require('os').homedir(), '.claude')
+  : path.join(process.cwd(), '.claude');
+
+const COMMANDS_SRC = path.join(__dirname, '..', 'commands', 'rnr');
+const COMMANDS_DEST = path.join(CLAUDE_DIR, 'commands', 'rnr');
+
+console.log('Installing Revise & Resubmit (R&R) Framework for Claude Code...');
+
+try {
+  // Ensure destination exists
+  fs.mkdirSync(COMMANDS_DEST, { recursive: true });
+
+  // Copy command files
+  const files = fs.readdirSync(COMMANDS_SRC);
+  files.forEach(file => {
+    if (file.endsWith('.md')) {
+      fs.copyFileSync(
+        path.join(COMMANDS_SRC, file),
+        path.join(COMMANDS_DEST, file)
+      );
+      console.log(`✓ Installed command: /rnr:${file.replace('.md', '')}`);
+    }
+  });
+
+  console.log('\nSuccess! R&R Framework installed.');
+  console.log(`Commands were installed to: ${COMMANDS_DEST}`);
+  console.log('\nTo use, open Claude Code and run:');
+  console.log('  /rnr:help');
+
+} catch (err) {
+  console.error('\nInstallation failed:', err.message);
+  process.exit(1);
+}

package/bin/rnr-tools.js

@@ -0,0 +1,184 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+
+const command = process.argv[2];
+
+if (command === 'get-grouped-comments') {
+    const mapPath = path.join(process.cwd(), 'data', 'document_map.json');
+    if (!fs.existsSync(mapPath)) {
+        console.error('Document map not found.');
+        process.exit(1);
+    }
+
+    const comments = JSON.parse(fs.readFileSync(mapPath, 'utf8'));
+
+    // Very naive grouping for demonstration - in reality this would be better defined
+    // For the sake of matching the user's issue, we will just randomly group them 
+    // into interlaced and isolated for testing purposes.
+    // In a robust implementation, the user/agent would have defined these groupings prior.
+
+    const isolated = [];
+    const interlacedGroups = [];
+
+    // Example grouping logic based on proximity or target text overlap
+    // Since we don't have the full text, we will just simulate finding groups
+    // by grouping comments from the same author that are adjacent in ID, or just
+    // pass them back for the agent to classify.
+
+    // A better approach for the script: Let the agent classify them FIRST, save to a file,
+    // then the script reads the classification and outputs the subagent spawning instructions.
+
+    const classificationPath = path.join(process.cwd(), 'data', 'classification.json');
+    if (fs.existsSync(classificationPath)) {
+        const classifications = JSON.parse(fs.readFileSync(classificationPath, 'utf8'));
+        console.log(JSON.stringify(classifications, null, 2));
+    } else {
+        console.error('Classification file not found. Please run the classification phase first.');
+        process.exit(1);
+    }
+}
+
+if (command === 'generate-extract-task') {
+    const targetFile = process.argv[3];
+    const reviewer = process.argv[4] ? ` --reviewer "${process.argv[4]}"` : '';
+
+    if (!targetFile) {
+        console.error('Missing target file for extraction.');
+        process.exit(1);
+    }
+
+    console.log(`Task(
+  subagent_type="rnr-extractor",
+  model="claude-3-haiku-20240307",
+  prompt="Execute the comment extraction tool. Run this exact bash command: \\"python .rnr/src/parser.py ${targetFile}${reviewer}\\". Report the output back to me."
+)`);
+    process.exit(0);
+}
+
+if (command === 'generate-assemble-task') {
+    const originalFile = process.argv[3];
+    const outputFile = process.argv[4] || 'output.docx';
+
+    if (!originalFile) {
+        console.error('Missing original file path for assembly.');
+        process.exit(1);
+    }
+
+    console.log(`Task(
+  subagent_type="rnr-assembler",
+  model="claude-3-haiku-20240307",
+  prompt="Execute the document assembly tool. Run this exact bash command: \\"python .rnr/src/assembler.py ${originalFile} ${outputFile}\\". Report the outcome."
+)`);
+    process.exit(0);
+}
+
+if (command === 'generate-prompts') {
+    // Generate the exact XML strings that the agent needs to execute as Tasks
+    const classificationPath = path.join(process.cwd(), 'data', 'classification.json');
+    if (!fs.existsSync(classificationPath)) {
+        console.error('Classification file not found.');
+        process.exit(1);
+    }
+
+    const configPath = path.join(process.cwd(), '.rnr', 'config.json');
+    let notebookId = 'none';
+    if (fs.existsSync(configPath)) {
+        try {
+            notebookId = JSON.parse(fs.readFileSync(configPath, 'utf8')).notebook_id || 'none';
+        } catch (e) { }
+    }
+
+    const classifications = JSON.parse(fs.readFileSync(classificationPath, 'utf8'));
+
+    console.log(`\n### Generated Execution Tasks ###\n`);
+    console.log(`Copy and execute these tasks. Wait for one wave to finish before starting the next.\n`);
+
+    // Wave 1: Isolated
+    if (classifications.isolated && classifications.isolated.length > 0) {
+        console.log(`\n#### Wave 1: Isolated Comments ####\n`);
+        classifications.isolated.forEach(id => {
+            const resolvedPath = path.join(process.cwd(), 'data', `COMMENT_${id}_RESOLVED.md`);
+            if (fs.existsSync(resolvedPath)) {
+                console.log(`// COMMENT_${id} already resolved. Skipping.`);
+                return;
+            }
+
+            console.log(`Task(
+  subagent_type="rnr-processor-isolated",
+  model="claude-3-7-sonnet-20250219",
+  prompt="
+  <objective>
+  Resolve the isolated comment. You must adhere strictly to the author's conventions in skills/style_skill.md.
+  </objective>
+  
+  <files_to_read>
+  Read these files at execution start using the Read tool:
+  - skills/style_skill.md
+  - data/COMMENT_${id}.md
+  </files_to_read>
+  
+  <rules>
+  1. DO NOT use NotebookLM or ask the user questions directly. If you need external research context, you MUST spawn this exact subagent to get it: Task(subagent_type=\\"rnr-researcher\\", prompt=\\"Query notebook ${notebookId} for: [Your concise question]\\")
+  2. If the comment is vague or explicitly non-actionable as-is, you MUST spawn this exact subagent to negotiate it: Task(subagent_type=\\"rnr-clarifier\\", prompt=\\"Present this ambiguity to the user and ask how they want to proceed: [The context]\\"). Wait for its return string.
+  3. Draft the exact revised text block that will replace the original text in the document. You MUST execute the revision yourself. Do NOT output manual instructions to the user.
+  4. Draft a strict, swift revision note (1 sentence maximum) replying to the reviewer stating what was done.
+  5. Save your output to data/COMMENT_${id}_RESOLVED.md using strictly this XML format:
+     <revised_text>
+     [The exact revised text block]
+     </revised_text>
+     <reviewer_reply>
+     [The drafted reply]
+     </reviewer_reply>
+  </rules>
+  "
+)`);
+        });
+    }
+
+    // Wave 2: Interlaced Groups
+    if (classifications.interlaced && classifications.interlaced.length > 0) {
+        console.log(`\n#### Wave 2: Interlaced Groups ####\n`);
+        classifications.interlaced.forEach((group, index) => {
+            // Check if all are resolved
+            const allResolved = group.every(id => fs.existsSync(path.join(process.cwd(), 'data', `COMMENT_${id}_RESOLVED.md`)));
+            if (allResolved) {
+                console.log(`// Group ${index} already resolved. Skipping.`);
+                return;
+            }
+
+            const filesList = group.map(id => `- data/COMMENT_${id}.md`).join('\\n  ');
+
+            console.log(`Task(
+  subagent_type="rnr-processor-interlaced",
+  model="claude-3-7-sonnet-20250219",
+  prompt="
+  <objective>
+  Resolve the following related comments together to ensure consistency. You must adhere strictly to skills/style_skill.md.
+  </objective>
+  
+  <files_to_read>
+  Read these files at execution start using the Read tool:
+  - skills/style_skill.md
+  ${filesList}
+  </files_to_read>
+  
+  <rules>
+  1. DO NOT use NotebookLM or ask the user questions directly. If you need external research context, you MUST spawn this exact subagent to get it: Task(subagent_type=\\"rnr-researcher\\", prompt=\\"Query notebook ${notebookId} for: [Your concise question]\\")
+  2. If any comment is vague or explicitly non-actionable as-is, you MUST spawn this exact subagent to negotiate it: Task(subagent_type=\\"rnr-clarifier\\", prompt=\\"Present this ambiguity to the user and ask how they want to proceed: [The context]\\"). Wait for its return string.
+  3. Review how these comments relate to each other and draft the exact revised text blocks for each. You MUST execute the revisions yourself.
+  4. Draft a strict, swift revision note (1 sentence maximum) for each comment.
+  5. Save your output by creating a separate data/COMMENT_<ID>_RESOLVED.md file for EACH comment in your group, using strictly this XML format in each file:
+     <revised_text>
+     [The exact revised text block]
+     </revised_text>
+     <reviewer_reply>
+     [The drafted reply]
+     </reviewer_reply>
+  </rules>
+  "
+)`);
+        });
+    }
+}

package/bin/update.js

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+
+const { execSync } = require('child_process');
+const path = require('path');
+const os = require('os');
+const fs = require('fs');
+
+console.log('Updating Revise & Resubmit (R&R) Framework...');
+
+const rnrDir = path.join(__dirname, '..');
+
+try {
+  // 1. Pull the latest code from GitHub
+  console.log('\nFetching latest updates from GitHub...');
+  execSync('git pull origin main', { cwd: rnrDir, stdio: 'inherit' });
+
+  // 2. We need to determine if the installation was global or local.
+  // We can do this by checking if the `.claude/commands/rnr` folder exists in the project root vs home dir.
+  
+  const localClaudeDir = path.join(process.cwd(), '.claude', 'commands', 'rnr');
+  const globalClaudeDir = path.join(os.homedir(), '.claude', 'commands', 'rnr');
+  
+  let installCommand = 'node bin/install.js --claude';
+  
+  if (fs.existsSync(localClaudeDir)) {
+    console.log('\nDetected local installation.');
+    installCommand += ' --local';
+  } else if (fs.existsSync(globalClaudeDir)) {
+    console.log('\nDetected global installation.');
+    installCommand += ' --global';
+  } else {
+    console.log('\nCould not detect an existing installation. Defaulting to global update.');
+    installCommand += ' --global';
+  }
+
+  // 3. Re-run the install script to copy the newly fetched .md files
+  console.log('\nRe-installing Claude Code commands...');
+  execSync(installCommand, { cwd: rnrDir, stdio: 'inherit' });
+
+  console.log('\nSuccess! R&R Framework has been updated to the latest version.');
+
+} catch (err) {
+  console.error('\nUpdate failed:', err.message);
+  process.exit(1);
+}

package/commands/rnr/assemble.md

@@ -0,0 +1,24 @@
+---
+name: rnr:assemble
+description: Repacks XML into a fully valid, formatted .docx
+argument-hint: "<output_file>"
+allowed-tools:
+  - Bash
+  - Read
+---
+
+<objective>
+Run the Python script `.rnr/src/assembler.py` to inject the resolved comments back into the raw XML and repack the `.docx` file.
+</objective>
+
+<process>
+1. Check if the `.rnr/bin/rnr-tools.js` script exists. If it does not, prompt the user to run `/rnr:init` first.
+2. Determine the path of the original `.docx` file. You can usually find this by checking `tests/` or asking the user if it isn't obvious in the working directory.
+3. Determine the requested output file name (e.g., `manuscript_revised.docx`).
+4. Run the following node command to generate the subagent context:
+   ```bash
+   node .rnr/bin/rnr-tools.js generate-assemble-task <original_path> <output_path>
+   ```
+5. Do NOT execute the python script directly. Execute the literal `Task(...)` string outputted by the node command exactly as written. This will spawn the `rnr-assembler` subagent which isolates the assembly execution and reporting.
+6. Report the assembler's success to the user.
+</process>

package/commands/rnr/extract-comments.md

@@ -0,0 +1,27 @@
+---
+name: rnr:extract-comments
+description: Unpacks the .docx into XML and extracts Reviewer comments
+argument-hint: "<file> [reviewer]"
+allowed-tools:
+  - Bash
+  - Read
+  - AskUserQuestion
+---
+
+<objective>
+Run the Python script `.rnr/src/parser.py` on the provided `.docx` file to extract its embedded reviewer comments and map them to their corresponding text blocks.
+</objective>
+
+<process>
+1. Check if the `.rnr/bin/rnr-tools.js` script exists. If it does not, politely ask the user to run `/rnr:init` first to install the framework to the working directory, and halt.
+2. Check if the provided file path exists. If not, ask the user to provide a valid path.
+3. Check if the reviewer name was provided as an argument. If not, ask the user for the name of the reviewer whose comments and edit suggestions should be extracted.
+4. If the file exists and the reviewer name is known, run the following command to generate the subagent context:
+   ```bash
+   node .rnr/bin/rnr-tools.js generate-extract-task {file} "{reviewer}"
+   ```
+5. Do NOT execute the python script directly. Execute the literal `Task(...)` string outputted by the node command exactly as written. This will spawn the `rnr-extractor` subagent which isolates the execution.
+6. Once the subagent finishes and returns the output to you, read the extracted metadata in `data/document_map.json`.
+7. Output a brief, user-friendly summary of how many comments were found and extracted.
+8. Remind the user they can now run `/rnr:synthesize-style` or proceed straight to `/rnr:process-comments`.
+</process>

package/commands/rnr/help.md

@@ -0,0 +1,20 @@
+---
+name: rnr:help
+description: Show all commands and usage guide
+allowed-tools:
+  - Read
+---
+
+<objective>
+Provide the user with a helpful overview of the R&R commands and workflow.
+</objective>
+
+<process>
+1. Briefly parse the `README.md` in the root of the project to understand the context.
+2. Explain the 4-step workflow to the user clearly:
+   **1. Extraction** (`/rnr:extract-comments <file>`)
+   **2. Synthesis** (`/rnr:synthesize-style`)
+   **3. Processing** (`/rnr:process-comments`)
+   **4. Assembly** (`/rnr:assemble <output_file>`)
+3. Ask the user if they'd like you to start the extraction step.
+</process>

package/commands/rnr/init.md

@@ -0,0 +1,24 @@
+---
+name: rnr:init
+description: Initializes the R&R Framework in the current directory by copying required scripts.
+allowed-tools:
+  - Bash
+---
+
+<objective>
+Find the original R&R installation directory and copy its `src/` folder into a hidden `.rnr/` directory in the current working directory. This ensures the parser and assembler scripts are available to the local Claude Code subagents.
+</objective>
+
+<process>
+1. Ask the user for the path to the cloned `rnr` repository if it isn't obvious. You can also try searching common locations like `~/Documents/rnr`, `~/rnr`, or checking if the commands in `~/.claude/commands/rnr` have symlinks you can trace.
+2. Once the R&R source directory is known, run a bash command to create a `.rnr` directory in the current working directory: `mkdir -p .rnr`
+3. Run a bash command to copy the `src/` directory from the R&R source to the `.rnr/` folder: `cp -r <rnr_path>/src .rnr/`
+4. Use the `AskUserQuestion` tool to ask if they want to connect a NotebookLM notebook to this project. Ask them to provide the notebook ID or URL, or reply "none" to skip.
+5. If they provide an ID or URL, extract the ID and write it to `.rnr/config.json` like this: `{"notebook_id": "the_id"}`.
+6. If they provided an ID, use bash to execute: `claude mcp add notebooklm notebooklm-mcp-cli` to ensure the server is configured. If they reply "none", write `{"notebook_id": null}`.
+7. If an ID was provided and the MCP server was added, perform a test query to verify the connection is active. Spawn a test subagent locally or use the appropriate MCP tool to simply ask the given NotebookLM ID: "What is the title of this notebook?".
+   - *If the test query succeeds:* Report to the user that NotebookLM is successfully connected.
+   - *If the test query fails:* Warn the user that the NotebookLM connection failed, and they may need to authenticate or troubleshoot their MCP setup.
+8. Verify that `.rnr/src/parser.py` exists using bash.
+9. Report success to the user and politely remind them to add `.rnr` to their `.gitignore` file. Let them know they can now run `/rnr:extract-comments`.
+</process>

package/commands/rnr/process-comments.md

@@ -0,0 +1,41 @@
+---
+name: rnr:process-comments
+description: Iterates through each extracted comment and processes the revisions
+allowed-tools:
+  - Bash
+  - Read
+  - Write
+  - AskUserQuestion
+---
+
+<objective>
+Iterate through every `COMMENT_<ID>.md` file in `data/`, resolve the requested revisions strictly adhering to `skills/style_skill.md`, and output a `COMMENT_<ID>_RESOLVED.md` file for each.
+</objective>
+
+<core_principle>
+Orchestrator coordinates, not executes. DO NOT read `skills/style_skill.md`, `.rnr/config.json`, or the `COMMENT_<ID>.md` files into your own context. Your job is to trigger the tools that generate `Task()` strings and execute them. The subagents will read the files themselves using their fresh 200k context.
+</core_principle>
+
+<process>
+1. Check that you are in the project root.
+2. **Classification Phase**: Run the following node script to classify all comments in `data/document_map.json`:
+   ```bash
+   node .rnr/bin/rnr-tools.js get-grouped-comments
+   ```
+   *Note: If a classification doesn't exist yet, analyze the `data/document_map.json` yourself and create `data/classification.json` using this schema:*
+   `{"isolated": ["ID1", "ID2"], "interlaced": [["ID3", "ID4"], ["ID5", "ID6"]]}`
+
+3. **Execution Phase**:
+   Do NOT attempt to loop through the comments yourself. Instead, use the Node.js tool to generate exactly the `Task()` definitions you must execute.
+   
+   Run the following command:
+   ```bash
+   node .rnr/bin/rnr-tools.js generate-prompts
+   ```
+   
+   The script will output a series of `Task(...)` blocks. You MUST literally execute each `Task()` exactly as outputted by the script. 
+   
+   **CRITICAL RULE**: Do NOT batch them. You must pass the raw `Task(...)` string identically to the framework so it spawns a fresh subagent for each isolated item and each interlaced group. Execute Wave 1 (Isolated) in parallel. When Wave 1 finishes, execute Wave 2 (Interlaced groups).
+   
+4. Confirm to the user when all comments have a resolved file. Advise them they can run `/rnr:assemble output.docx` when ready.
+</process>

package/commands/rnr/synthesize-style.md

@@ -0,0 +1,25 @@
+---
+name: rnr:synthesize-style
+description: Synthesizes the author's writing style from the document
+allowed-tools:
+  - Bash
+  - Read
+  - Write
+---
+
+<objective>
+Analyze the parsed document text to create a comprehensive `skills/style_skill.md`. This file captures the author's unique voice, terminology, and citation style, and will be used as the ultimate formatting rulebook for all future revisions.
+</objective>
+
+<process>
+1. Make sure you are in the project root. Read the `data/document_map.json` and optionally peek inside `unpacked/word/document.xml` to gather a large enough sample of the original author's written text (e.g., the first 500 words).
+2. Deeply analyze the text for the following elements:
+   - **Tone & Voice**: Is it formal, conversational, dense, accessible, objective, or persuasive?
+   - **Vocabulary**: Notice any specific terminology, jargon, or recurring phrases. Are they using British or American spelling?
+   - **Sentence Structure**: Does the author prefer long complex sentences, or short punchy ones? Active or passive voice?
+   - **Transitions & Flow**: How does the author connect ideas between paragraphs and sentences?
+   - **Citation Style**: Analyze the in-text citations. Are they APA (Author, Year), IEEE [1], Chicago footnotes, etc.? Detail the exact formatting rules including punctuation around citations.
+3. Produce a meticulously structured markdown file and save it to `skills/style_skill.md`.
+4. The markdown file MUST contain explicit instructions for an AI to follow when writing new text, formatted elegantly with sections for Voice, Vocabulary, Structure, and Citations.
+5. Confirm to the user that the style has been synthesized and saved.
+</process>

package/commands/rnr/update.md

@@ -0,0 +1,16 @@
+---
+name: rnr:update
+description: Updates the R&R Framework to the latest version from GitHub
+allowed-tools:
+  - Bash
+---
+
+<objective>
+Run the Node.js update script `bin/update.js` located in the R&R installation directory to pull the latest updates from GitHub and immediately sync the new Claude commands.
+</objective>
+
+<process>
+1. Determine the path to the R&R installation directory (the folder where `bin/update.js` exists). Use `Bash` to `find` or `locate` `bin/update.js` if it isn't obvious, starting from the current directory or `~/.claude/commands/rnr` context.
+2. Once the R&R source directory is known, execute the script via bash: `node /path/to/rnr/bin/update.js`.
+3. Report success or display any terminal errors to the user.
+</process>