rrce-workflow 0.2.52 → 0.2.54

package/agent-core/prompts/doctor.md

@@ -0,0 +1,142 @@
+---
+name: RRCE Doctor
+description: Analyze codebase health, identify issues, and recommend tasks for the planning agent.
+argument-hint: [PROJECT_NAME=<name>]
+tools: ['search_knowledge', 'get_project_context', 'file_listing']
+required-args: []
+optional-args:
+  - name: PROJECT_NAME
+    default: ""
+    prompt: "Enter project name (leave blank to use active project)"
+  - name: FOCUS_AREA
+    default: ""
+    prompt: "Specific area to analyze (e.g., 'performance', 'security', 'architecture', 'testing')"
+auto-identity:
+  user: "$GIT_USER"
+  model: "$AGENT_MODEL"
+---
+
+You are the Project Doctor for RRCE-Workflow. Operate like a senior technical consultant performing a health check on the codebase to identify issues, technical debt, and improvement opportunities.
+
+**⚠️ FIRST STEP (MANDATORY)**
+Before doing ANY work, read `.rrce-workflow/config.yaml` (if it exists) and resolve these variables:
+```
+RRCE_HOME = config.storage.globalPath OR "~/.rrce-workflow"
+RRCE_DATA = (config.storage.mode == "workspace") ? ".rrce-workflow/" : "${RRCE_HOME}/workspaces/${config.project.name}/"
+```
+If config doesn't exist, use defaults: `RRCE_HOME=~/.rrce-workflow`, `RRCE_DATA=.rrce-workflow/`
+
+## Pipeline Position
+- **Input**: Can be triggered at any time for project health analysis.
+- **Output**: A structured task request for the `planning` agent.
+- **Dependency**: Relies on `project-context.md` from the `init` agent for baseline understanding.
+
+## Mission
+- Analyze the codebase for health issues, technical debt, and improvement opportunities.
+- Produce actionable task recommendations that can be handed off to the Planning agent.
+- Focus on high-impact, measurable improvements.
+
+## Non-Negotiables
+1. Always read `project-context.md` first to understand the project.
+2. Base recommendations on evidence found in the code, not assumptions.
+3. Prioritize issues by impact and effort.
+4. Output must be in the format expected by the Planning agent.
+5. Be specific and actionable; vague recommendations are useless.
+
+## Analysis Workflow
+
+### 1. Context Gathering
+- Read `{{RRCE_DATA}}/knowledge/project-context.md`
+- Identify tech stack, testing strategy, and coding conventions
+- Note existing constraints and requirements
+
+### 2. Health Checks (run applicable ones based on project type)
+
+#### Code Quality
+- [ ] Identify large files that may need splitting (>500 lines)
+- [ ] Find functions/methods with high complexity
+- [ ] Check for code duplication patterns
+- [ ] Review error handling consistency
+- [ ] Check for TODO/FIXME/HACK comments
+
+#### Architecture
+- [ ] Identify circular dependencies
+- [ ] Check for proper separation of concerns
+- [ ] Review module boundaries and coupling
+- [ ] Assess API design consistency
+- [ ] Check for proper abstraction levels
+
+#### Testing
+- [ ] Assess test coverage (if metrics available)
+- [ ] Identify untested critical paths
+- [ ] Check test organization and naming
+- [ ] Review test quality and brittleness
+
+#### Security (if applicable)
+- [ ] Identify hardcoded credentials or secrets
+- [ ] Check for common vulnerability patterns
+- [ ] Review input validation practices
+- [ ] Check dependency vulnerabilities (if package audit available)
+
+#### Performance
+- [ ] Identify potential N+1 queries or inefficient loops
+- [ ] Check for missing caching opportunities
+- [ ] Review bundle size concerns (for frontend)
+- [ ] Identify memory leak patterns
+
+#### DevOps & Maintainability
+- [ ] Review CI/CD configuration completeness
+- [ ] Check documentation freshness
+- [ ] Assess onboarding experience
+- [ ] Review dependency update status
+
+### 3. Issue Prioritization
+
+Rank findings using this matrix:
+
+| Priority | Impact | Effort | Action |
+|----------|--------|--------|--------|
+| P0 - Critical | High | Any | Immediate fix required |
+| P1 - High | High | Low-Medium | Address in current sprint |
+| P2 - Medium | Medium | Low-Medium | Schedule for next sprint |
+| P3 - Low | Low | Low | Nice to have, opportunistic |
+| Backlog | Any | High | Consider for major refactoring |
+
+### 4. Generate Task Recommendations
+
+For each significant finding, create a task recommendation with:
+- Clear title
+- Problem statement
+- Proposed solution
+- Acceptance criteria
+- Estimated effort
+- Dependencies
+
+## Deliverable
+
+- **File**: `{{RRCE_DATA}}/tasks/doctor-{{timestamp}}/diagnosis.md`
+- **Format**: Use `{{RRCE_HOME}}/templates/doctor_output.md`
+- **Outcome**: Structured diagnosis with actionable tasks for the Planning agent
+
+## Integration Notes
+
+- **Planning Agent**: Receives the diagnosis and creates execution plans for high-priority items.
+- **Init Agent**: Doctor relies on updated `project-context.md`; may trigger Init if context is stale.
+- **Executor Agent**: Will implement the planned tasks derived from Doctor's recommendations.
+
+## When to Run
+
+- After major features are completed (retrospective analysis)
+- Before starting a new development phase
+- When onboarding new team members (to understand tech debt)
+- Periodically (e.g., monthly) for preventive maintenance
+- When performance or quality issues are reported
+
+## Focus Area Guidance
+
+If `{{FOCUS_AREA}}` is provided, prioritize that area:
+- `performance`: Focus on N+1, caching, bundle size, memory
+- `security`: Focus on auth, input validation, secrets, dependencies
+- `architecture`: Focus on coupling, dependencies, abstractions
+- `testing`: Focus on coverage, test quality, missing tests
+- `maintainability`: Focus on docs, complexity, onboarding

package/agent-core/prompts/executor.md

@@ -79,6 +79,9 @@ Workflow
 4. Record checkpoints, blockers, and validation steps in `agents.executor.notes` and `references`.
 5. Capture your implementation log using `{{RRCE_HOME}}/templates/executor_output.md` and save it to `{{RRCE_DATA}}/tasks/{{TASK_SLUG}}/execution/{{TASK_SLUG}}-execution.md`, noting the provided `BRANCH` or current git ref.
 6. Summarize test evidence, code pointers, and outstanding follow-ups so documentation can build on it seamlessly.
+7. **Semantic Indexing**: If significant code was added or modified, suggest running `index_knowledge` to update the semantic search index:
+   - Tool: `index_knowledge`
+   - Args: `{ project: "{{WORKSPACE_NAME}}" }`
 
 Deliverable
 - File: `{{RRCE_DATA}}/tasks/{{TASK_SLUG}}/execution/{{TASK_SLUG}}-execution.md`

package/agent-core/prompts/init.md

@@ -162,10 +162,16 @@ Workflow Steps
 7. Save to `{{RRCE_DATA}}/knowledge/project-context.md`.
 8. Update `{{RRCE_DATA}}/workspace.json` with project metadata.
 9. Log changes made (new sections, updated sections, removed outdated info).
-10. **Semantic Indexing**: If the `index_knowledge` tool is available, run it:
-    - Tool: `index_knowledge`
-    - Args: `{ project: "{{WORKSPACE_NAME}}" }`
-    - This ensures the new context is immediately searchable.
+10. **Semantic Index Status & Indexing**: 
+    - Determine if semantic search is enabled (check config or look for `embeddings.json` existence).
+    - If `index_knowledge` tool is available and enabled:
+      - Run it: `index_knowledge` with `{ project: "{{WORKSPACE_NAME}}" }`.
+      - Capture the result (files indexed, skipped, totals).
+    - Populate Section 11 "Semantic Index Status" in the template with:
+      - Enabled: yes/no
+      - Last Indexed: Current time (if you just ran it) or file modification time of `embeddings.json`.
+      - Index Location: Path to `embeddings.json`.
+      - Totals: Use data from `index_knowledge` output if avail.
 
 Deliverable
 - File: `{{RRCE_DATA}}/knowledge/project-context.md`

package/agent-core/prompts/planning_orchestrator.md

@@ -73,6 +73,9 @@ Workflow
 3. Where new persistent knowledge is created (API notes, domain decisions, etc.), append or create records in `{{RRCE_DATA}}/knowledge/{{DOMAIN}}.md` and log the file path inside `meta.json.references`.
 4. Structure the plan using `{{RRCE_HOME}}/templates/planning_output.md` and store it at `{{RRCE_DATA}}/tasks/{{TASK_SLUG}}/planning/{{TASK_SLUG}}-plan.md`.
 5. Provide clear guidance on validation, testing strategy, rollout sequencing, and success criteria for the Executor.
+6. **Semantic Indexing**: If new knowledge files were created in `{{RRCE_DATA}}/knowledge/`, suggest running `index_knowledge` to update the semantic search index:
+   - Tool: `index_knowledge`
+   - Args: `{ project: "{{WORKSPACE_NAME}}" }`
 
 Deliverable
 - File: `{{RRCE_DATA}}/tasks/{{TASK_SLUG}}/planning/{{TASK_SLUG}}-plan.md`

package/agent-core/templates/doctor_output.md

@@ -0,0 +1,127 @@
+<!--
+  RRCE Template Variables:
+  - {{RRCE_DATA}}: Primary storage path (resolves based on storage mode in .rrce-workflow/config.yaml)
+      - global: {{RRCE_HOME}}/workspaces/<workspace-name>/
+      - workspace: <workspace>/.rrce-workflow/
+  - {{RRCE_HOME}}: Global home (default: ~/.rrce-workflow, customizable via storage.globalPath in config)
+  - {{WORKSPACE_ROOT}}: Workspace root directory
+  - {{WORKSPACE_NAME}}: Workspace name from config or directory name
+-->
+# Project Diagnosis – {{project_name}}
+
+- Diagnosis Date: `{{date}}`
+- Analyst: `{{author}}`
+- Workspace: `{{workspace_root}}`
+- Focus Area: `{{focus_area}}` (or "General" if not specified)
+- Project Context: `{{RRCE_DATA}}/knowledge/project-context.md`
+
+---
+
+## Executive Summary
+
+A brief 2-3 sentence summary of the overall codebase health and most critical findings.
+
+---
+
+## Health Score
+
+| Category | Score (1-5) | Notes |
+|----------|-------------|-------|
+| Code Quality |  |  |
+| Architecture |  |  |
+| Testing |  |  |
+| Security |  |  |
+| Performance |  |  |
+| Maintainability |  |  |
+| **Overall** |  |  |
+
+*Scale: 1=Critical issues, 2=Significant issues, 3=Acceptable, 4=Good, 5=Excellent*
+
+---
+
+## Critical Findings (P0-P1)
+
+### Finding 1: [Title]
+- **Category**: (Code Quality / Architecture / Testing / Security / Performance)
+- **Priority**: P0 / P1
+- **Impact**: High
+- **Effort**: Low / Medium / High
+- **Location**: `path/to/file.ts:L42-L100`
+- **Description**: What is the problem?
+- **Evidence**: Code snippets, metrics, or specific examples.
+- **Recommendation**: What should be done?
+- **Acceptance Criteria**:
+  - [ ] Criterion 1
+  - [ ] Criterion 2
+
+---
+
+## Medium Priority Findings (P2)
+
+### Finding N: [Title]
+- **Category**: 
+- **Priority**: P2
+- **Impact**: Medium
+- **Effort**: 
+- **Description**: 
+- **Recommendation**: 
+
+---
+
+## Low Priority / Backlog (P3+)
+
+| Finding | Category | Effort | Notes |
+|---------|----------|--------|-------|
+|  |  |  |  |
+
+---
+
+## Recommended Tasks for Planning Agent
+
+> These are ready-to-use task definitions for the `planning` agent.
+
+### Task 1: [Suggested Title]
+```yaml
+title: "[ACTION] [COMPONENT]: [Goal]"
+priority: P1
+category: refactoring / bugfix / feature / docs
+description: |
+  Brief description of what needs to be done and why.
+acceptance_criteria:
+  - Criterion 1
+  - Criterion 2
+estimated_effort: "2-4 hours / 1-2 days / 1 week"
+dependencies:
+  - Any blocking tasks or requirements
+context_artifacts:
+  - "{{RRCE_DATA}}/knowledge/project-context.md"
+  - "path/to/relevant/file.ts"
+```
+
+### Task 2: [Suggested Title]
+```yaml
+# ... repeat format
+```
+
+---
+
+## Metrics & Data
+
+Any relevant metrics collected during analysis:
+- Lines of code: 
+- Files analyzed: 
+- Test coverage (if available): 
+- Dependency count: 
+- TODO/FIXME comments found: 
+
+---
+
+## Next Steps
+
+1. Review findings with team/stakeholder
+2. Hand off high-priority tasks to `planning` agent: `rrce-workflow run planning --task="<Task Title>"`
+3. Schedule follow-up diagnosis in: [timeframe]
+
+---
+
+> This diagnosis is based on automated analysis and code review. Human judgment should validate recommendations before implementation.

package/agent-core/templates/init_output.md

@@ -256,10 +256,26 @@ Based on the tech stack analysis, the Executor agent should have proficiency in:
 |----------|----------|-------|
 |  | high/medium/low |  |
 
+
+---
+
+## 11. Semantic Index Status
+
+| Attribute | Value |
+|-----------|-------|
+| **Enabled** | yes / no |
+| **Last Indexed** | `{{last_indexed_date}}` |
+| **Index Location** | `{{index_path}}` |
+| **Total Files** |  |
+| **Total Chunks** |  |
+
+*If semantic search is enabled, run `index_knowledge` to update the index after significant changes.*
+
 ---
 
 ## Checklist
 
+
 - [ ] Tech stack fully documented
 - [ ] Coding conventions captured
 - [ ] Testing strategy clear

package/dist/index.js

@@ -374,7 +374,7 @@ import * as path3 from "path";
 import * as readline from "readline";
 import pc from "picocolors";
 function directoryPrompt(opts) {
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     process.stdout.write(`${pc.cyan("\u25C6")}  ${opts.message}
 `);
     process.stdout.write(`${pc.cyan("\u2502")}  `);
@@ -403,14 +403,14 @@ function directoryPrompt(opts) {
       rl.close();
       process.stdout.write(`${pc.green("\u2713")}  ${pc.dim(expandedPath)}
 `);
-      resolve(expandedPath);
+      resolve2(expandedPath);
     });
     rl.on("close", () => {
     });
     rl.on("SIGINT", () => {
       rl.close();
       process.stdout.write("\n");
-      resolve(/* @__PURE__ */ Symbol("cancel"));
+      resolve2(/* @__PURE__ */ Symbol("cancel"));
     });
   });
 }
@@ -762,6 +762,12 @@ function loadPromptsFromDir(dirPath) {
   return prompts;
 }
 function getAgentCoreDir() {
+  if (__dirname.includes("/src/") || __dirname.includes("\\src\\")) {
+    if (fs5.existsSync(path6.join(process.cwd(), "agent-core"))) {
+      return path6.join(process.cwd(), "agent-core");
+    }
+    return path6.resolve(__dirname, "../..", "agent-core");
+  }
   return path6.join(__dirname, "..", "agent-core");
 }
 function getAgentCorePromptsDir() {
@@ -1468,11 +1474,25 @@ var init_rag = __esm({
         }
       }
       /**
-       * Index a file
+       * Index a file (smart: skips if mtime unchanged)
+       * @param filePath Absolute path to the file
+       * @param content File content
+       * @param mtime Optional modification time (if not provided, always re-indexes)
+       * @returns true if file was indexed, false if skipped
        */
-      async indexFile(filePath, content) {
+      async indexFile(filePath, content, mtime) {
         this.loadIndex();
         if (!this.index) throw new Error("Index not initialized");
+        if (!this.index.fileMetadata) {
+          this.index.fileMetadata = {};
+        }
+        if (mtime !== void 0 && this.index.fileMetadata[filePath]) {
+          const existingMeta = this.index.fileMetadata[filePath];
+          if (existingMeta.mtime === mtime) {
+            logger.debug(`RAG: Skipping unchanged file ${filePath}`);
+            return false;
+          }
+        }
         logger.info(`RAG: Indexing file ${filePath}`);
         this.index.chunks = this.index.chunks.filter((c) => c.filePath !== filePath);
         const chunks = this.chunkContent(content);
@@ -1482,10 +1502,16 @@ var init_rag = __esm({
             id: `${filePath}-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
             filePath,
             content: chunkText,
-            embedding
+            embedding,
+            mtime
           });
         }
+        this.index.fileMetadata[filePath] = {
+          mtime: mtime ?? Date.now(),
+          chunkCount: chunks.length
+        };
         this.saveIndex();
+        return true;
       }
       /**
        * Remove a file from index
@@ -1495,11 +1521,36 @@ var init_rag = __esm({
         if (!this.index) return;
         const initialCount = this.index.chunks.length;
         this.index.chunks = this.index.chunks.filter((c) => c.filePath !== filePath);
+        if (this.index.fileMetadata) {
+          delete this.index.fileMetadata[filePath];
+        }
         if (this.index.chunks.length !== initialCount) {
           logger.info(`RAG: Removed file ${filePath} from index (${initialCount - this.index.chunks.length} chunks removed)`);
           this.saveIndex();
         }
       }
+      /**
+       * Get index statistics
+       */
+      getStats() {
+        this.loadIndex();
+        if (!this.index) return { totalChunks: 0, totalFiles: 0 };
+        const fileCount = this.index.fileMetadata ? Object.keys(this.index.fileMetadata).length : 0;
+        return {
+          totalChunks: this.index.chunks.length,
+          totalFiles: fileCount,
+          lastFullIndex: this.index.lastFullIndex
+        };
+      }
+      /**
+       * Mark the last full index timestamp
+       */
+      markFullIndex() {
+        this.loadIndex();
+        if (!this.index) return;
+        this.index.lastFullIndex = Date.now();
+        this.saveIndex();
+      }
       /**
        * Search the index
        */
@@ -1735,31 +1786,102 @@ async function indexKnowledge(projectName, force = false) {
   const projects = getExposedProjects();
   const project = projects.find((p) => p.name === projectName || p.path && p.path === projectName);
   if (!project) {
-    return { success: false, message: `Project '${projectName}' not found`, filesIndexed: 0 };
+    return { success: false, message: `Project '${projectName}' not found`, filesIndexed: 0, filesSkipped: 0 };
   }
   const projConfig = config.projects.find(
     (p) => p.path && p.path === project.dataPath || !p.path && p.name === project.name
   );
   if (!projConfig?.semanticSearch?.enabled) {
-    return { success: false, message: "Semantic Search is not enabled for this project", filesIndexed: 0 };
-  }
-  if (!project.knowledgePath || !fs13.existsSync(project.knowledgePath)) {
-    return { success: false, message: "No knowledge directory found", filesIndexed: 0 };
-  }
+    return { success: false, message: "Semantic Search is not enabled for this project", filesIndexed: 0, filesSkipped: 0 };
+  }
+  const scanRoot = project.path || project.dataPath;
+  if (!fs13.existsSync(scanRoot)) {
+    return { success: false, message: "Project root not found", filesIndexed: 0, filesSkipped: 0 };
+  }
+  const INDEXABLE_EXTENSIONS = [
+    ".ts",
+    ".tsx",
+    ".js",
+    ".jsx",
+    ".mjs",
+    ".cjs",
+    ".py",
+    ".pyw",
+    ".go",
+    ".rs",
+    ".java",
+    ".kt",
+    ".kts",
+    ".c",
+    ".cpp",
+    ".h",
+    ".hpp",
+    ".cs",
+    ".rb",
+    ".php",
+    ".swift",
+    ".md",
+    ".mdx",
+    ".json",
+    ".yaml",
+    ".yml",
+    ".toml",
+    ".sh",
+    ".bash",
+    ".zsh",
+    ".sql",
+    ".html",
+    ".css",
+    ".scss",
+    ".sass",
+    ".less"
+  ];
+  const SKIP_DIRS = ["node_modules", ".git", "dist", "build", ".next", "__pycache__", "venv", ".venv", "target", "vendor"];
   try {
-    const indexPath = path14.join(project.knowledgePath, "embeddings.json");
+    const indexPath = path14.join(project.knowledgePath || path14.join(scanRoot, ".rrce-workflow", "knowledge"), "embeddings.json");
     const rag = new RAGService(indexPath, projConfig.semanticSearch.model);
-    const files = fs13.readdirSync(project.knowledgePath).filter((f) => f.endsWith(".md"));
-    let count = 0;
-    for (const file of files) {
-      const filePath = path14.join(project.knowledgePath, file);
-      const content = fs13.readFileSync(filePath, "utf-8");
-      await rag.indexFile(path14.join(project.knowledgePath, file), content);
-      count++;
-    }
-    return { success: true, message: `Successfully indexed ${count} files`, filesIndexed: count };
+    let indexed = 0;
+    let skipped = 0;
+    const scanDir = async (dir) => {
+      const entries = fs13.readdirSync(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = path14.join(dir, entry.name);
+        if (entry.isDirectory()) {
+          if (SKIP_DIRS.includes(entry.name) || entry.name.startsWith(".")) {
+            continue;
+          }
+          await scanDir(fullPath);
+        } else if (entry.isFile()) {
+          const ext = path14.extname(entry.name).toLowerCase();
+          if (!INDEXABLE_EXTENSIONS.includes(ext)) {
+            continue;
+          }
+          try {
+            const stat = fs13.statSync(fullPath);
+            const mtime = force ? void 0 : stat.mtimeMs;
+            const content = fs13.readFileSync(fullPath, "utf-8");
+            const wasIndexed = await rag.indexFile(fullPath, content, mtime);
+            if (wasIndexed) {
+              indexed++;
+            } else {
+              skipped++;
+            }
+          } catch (err) {
+          }
+        }
+      }
+    };
+    await scanDir(scanRoot);
+    rag.markFullIndex();
+    const stats = rag.getStats();
+    return {
+      success: true,
+      message: `Indexed ${indexed} files, skipped ${skipped} unchanged. Total: ${stats.totalChunks} chunks from ${stats.totalFiles} files.`,
+      filesIndexed: indexed,
+      filesSkipped: skipped
+    };
   } catch (error) {
-    return { success: false, message: `Indexing failed: ${error}`, filesIndexed: 0 };
+    return { success: false, message: `Indexing failed: ${error}`, filesIndexed: 0, filesSkipped: 0 };
   }
 }
 function getContextPreamble() {
@@ -2644,7 +2766,12 @@ var init_Overview = __esm({
             /* @__PURE__ */ jsx2(Text2, { children: "Server Port: " }),
             /* @__PURE__ */ jsx2(Text2, { color: "cyan", children: serverStatus.port })
           ] }),
-          /* @__PURE__ */ jsx2(Box2, { marginTop: 1, children: /* @__PURE__ */ jsx2(Text2, { color: "dim", children: "Press 'q' to stop server and exit." }) })
+          /* @__PURE__ */ jsxs(Box2, { marginTop: 1, flexDirection: "column", children: [
+            /* @__PURE__ */ jsx2(Text2, { color: "dim", children: "Controls:" }),
+            /* @__PURE__ */ jsx2(Text2, { color: "dim", children: "  \u2022 Press 'r' to restart server" }),
+            /* @__PURE__ */ jsx2(Text2, { color: "dim", children: "  \u2022 Use 1-4 or \u25C4/\u25BA to navigate tabs" }),
+            /* @__PURE__ */ jsx2(Text2, { color: "dim", children: "  \u2022 Press 'q' to stop server and exit" })
+          ] })
         ] })
       ] });
     };
@@ -3034,7 +3161,7 @@ var init_App = __esm({
     ];
     App = ({ onExit, initialPort }) => {
       const { exit } = useApp();
-      const [activeTab, setActiveTab] = useState4("logs");
+      const [activeTab, setActiveTab] = useState4("overview");
       const [logs, setLogs] = useState4([]);
       const [serverInfo, setServerInfo] = useState4({
         port: initialPort,
@@ -3107,12 +3234,24 @@ var init_App = __esm({
         }, 500);
         return () => clearInterval(interval);
       }, []);
-      useInput3((input, key) => {
+      useInput3(async (input, key) => {
         if (input === "q" || key.ctrl && input === "c") {
           stopMCPServer();
           onExit();
           exit();
         }
+        if (input === "r") {
+          setLogs((prev) => [...prev, "[INFO] Restarting server..."]);
+          stopMCPServer();
+          setServerInfo((prev) => ({ ...prev, running: false }));
+          try {
+            const res = await startMCPServer({ interactive: true });
+            setServerInfo((prev) => ({ ...prev, running: true, port: res.port, pid: res.pid }));
+            setLogs((prev) => [...prev, "[INFO] Server restarted successfully"]);
+          } catch (e) {
+            setLogs((prev) => [...prev, `[ERROR] Failed to restart: ${e}`]);
+          }
+        }
       });
       const termHeight = process.stdout.rows || 24;
       const contentHeight = termHeight - 8;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rrce-workflow",
-  "version": "0.2.52",
+  "version": "0.2.54",
   "description": "RRCE-Workflow TUI - Agentic code workflow generator for AI-assisted development",
   "author": "RRCE Team",
   "license": "MIT",