@reactive-skills/runtime 0.3.0 → 0.4.1

package/CHANGELOG.md

@@ -0,0 +1,53 @@
+
+## [0.4.1] - 2026-09-14
+
+- feat(runtime,axi): add mcp job tools, template jobId context, and flexible jobs cli arguments (2b31451)
+- feat(mcp): add reactive_switch_job and reactive_archive_job tools with active job indicators
+- feat(projections): expose jobId directly in ProjectionContext for Handlebars templates
+- feat(axi): support bidirectional argument ordering in jobs command (jobs list <skill> and jobs <skill> list)
+- docs: introduce PERFORMANCE-STANDARDS.md for P0-P3 latency budgets, caching tiers, and CRAP score limits
+
+## [0.4.0] - 2026-09-14
+
+- feat(axi): implement native validate command for skill manifest and statechart verification (3b75a21)
+- docs: add v0.3.0 release highlights to READMEs and bundle changelog in package files (732f72b)
+- chore: release v0.3.0 (ae379ca)
+- feat(core): implement job management, isolated run storage, dual-write projections, and AXI jobs suite (c76c6cb)
+- chore: release v0.2.0 (bb33cfc)
+
+## [0.3.0] - 2026-09-13
+
+- feat(core): implement job management, isolated run storage, dual-write projections, and AXI jobs suite (c76c6cb)
+
+## [2.0.0] - 2026-09-01
+
+- feat: implement SQLite event store engine, state snapshotting, and JSONL log rotation with supporting documentation (6912493)
+- feat: implement skill-scoped SQLite event storage and migration infrastructure (b28fb19)
+- feat: implement core event-store with SQLite persistence, FSM engine, and projection tracking. (5926118)
+- feat: implement reactive skill core with FSM engine, event-sourced SQLite storage, and Zod-validated manifest schemas (b542c0a)
+- feat: add CLI tool for reactive skill management, project documentation, and state inspection workflows (39830d0)
+
+## [1.0.3] - 2026-08-31
+
+- refactor(core): migrate to clean semantic state filenames and convention-over-configuration resolution (8180b1b)
+- feat(hitl): add pre-implementation collaboration gate with 3 interaction modes (direct build, brainstorm, plan review) (0cd22b7)
+- fix(core): resolve P2 memory leak - add bounded in-memory sliding buffer with SQLite backing (7fefae5)
+- fix(core): resolve all Principal Engineer review findings - state rehydration, lifecycle signal queue, VM sandbox, and dual-write durability (791753e)
+- feat(mcp): add reactive_migrate tool to MCP server suite (e35779c)
+
+## [1.0.2] - 2026-08-31
+
+- chore(release): add automated multi-file semver bumping script and changelog generator (d0f9abd)
+- feat(docs): add automated doc invariant checker script and synchronize all project docs (280a95d)
+- feat(core): upgrade to v2 with Event Modeling 4-slice CQRS, statechart topology validation, and retroactive migration (c9801ed)
+- docs: clarify workspace layout, file destination paths, and greenfield/brownfield execution (1c79455)
+- docs: add Model Context Protocol (MCP) server documentation to README, architecture, and AGENTS (f2e638b)
+# Changelog
+
+## [1.0.1] - 2026-08-31
+
+- feat(docs): add automated doc invariant checker script and synchronize all project docs (280a95d)
+- feat(core): upgrade to v2 with Event Modeling 4-slice CQRS, statechart topology validation, and retroactive migration (c9801ed)
+- docs: clarify workspace layout, file destination paths, and greenfield/brownfield execution (1c79455)
+- docs: add Model Context Protocol (MCP) server documentation to README, architecture, and AGENTS (f2e638b)
+- feat(mcp): build universal reactive-mcp-server with 6 tools and live resources (9a01807)

package/README.md

@@ -1,6 +1,8 @@
 # @reactive-skills/runtime
 
-Reactive Skills Architecture (RSA) core runtime - FSM engine, event store, guard evaluator, projection engine, and MCP server.
+Reactive Skills Architecture (RSA) core runtime — FSM engine, event store, guard evaluator, projection engine, job manager, and MCP server.
+
+> 🚀 **What's New in v0.4.1:** MCP job management tools (`reactive_switch_job`, `reactive_archive_job`), template-level `jobId` context, and `PERFORMANCE-STANDARDS.md`. [Read Full Release Notes →](https://github.com/Reactive-Skills/reactive-skills/releases/tag/v0.4.1) · [View Changelog](https://github.com/Reactive-Skills/reactive-skills/blob/main/CHANGELOG.md)
 
 ## Installation
 
@@ -11,15 +13,16 @@ npm install @reactive-skills/runtime
 ## Usage
 
 ```ts
-import { FSMEngine, EventStore, LegacySkillAdapter, ProjectionEngine } from '@reactive-skills/runtime';
+import { FSMEngine, EventStore, JobManager, LegacySkillAdapter, ProjectionEngine } from '@reactive-skills/runtime';
 ```
 
 ## Core Modules
 
 - `FSMEngine` - Hierarchical State Machine loader, state path resolver, and signal-driven transition engine
+- `JobManager` - Run isolation, active pointer resolution, metadata management, and safe directory pathing
 - `EventStore` - Immutable append-only event ledger (JSONL + SQLite)
 - `GuardEvaluator` - Sandbox evaluator for transition guard expressions
-- `ProjectionEngine` - Handlebars deliverable generator for read-model projections
+- `ProjectionEngine` - Handlebars deliverable generator for read-model projections with dual-write archiving
 - `LegacySkillAdapter` - Backward compatibility wrapper and converter for SKILL.md
 - `McpServer` - Stdio Model Context Protocol (MCP) server integration
 - `TelemetryServer` - Real-time Server-Sent Events (SSE) broadcaster and Private Network Access (PNA) HTTP bridge

package/dist/core/projection-engine.d.ts

@@ -3,6 +3,7 @@ import { EventStore } from './event-store.js';
 export interface ProjectionContext {
     skillName: string;
     currentState: string;
+    jobId?: string;
     context: Record<string, any>;
     events: SignalEvent[];
     transitions: {

package/dist/core/projection-engine.js

@@ -125,6 +125,7 @@ export class ProjectionEngine {
         const projContext = {
             skillName,
             currentState,
+            jobId: this.jobId,
             context,
             events,
             transitions,

package/dist/mcp/server.js

@@ -455,7 +455,10 @@ export function createReactiveMcpServer(options = {}) {
             const targetSkill = skill || defaultSkill;
             const jobManager = new JobManager(workspaceDir);
             const activeJobId = jobManager.getActiveJobId(targetSkill);
-            const jobs = jobManager.listJobs(targetSkill);
+            const jobs = jobManager.listJobs(targetSkill).map(j => ({
+                ...j,
+                isActive: j.id === activeJobId,
+            }));
             return {
                 content: [
                     {
@@ -476,6 +479,106 @@ export function createReactiveMcpServer(options = {}) {
             };
         }
     });
+    // 10. TOOL: reactive_switch_job
+    server.tool('reactive_switch_job', 'Switch the active execution job pointer for a reactive skill and synchronize deliverables', {
+        skill: z.string().optional().describe('Name of the reactive skill (defaults to active skill)'),
+        job_id: z.string().describe('Target job ID to set as active'),
+    }, async ({ skill, job_id }) => {
+        try {
+            const skillName = skill || defaultSkill;
+            const jobManager = new JobManager(workspaceDir);
+            const job = jobManager.getJob(skillName, job_id);
+            if (!job) {
+                return {
+                    content: [{ type: 'text', text: JSON.stringify({ error: `Job '${job_id}' not found for skill '${skillName}'` }) }],
+                    isError: true,
+                };
+            }
+            jobManager.setActiveJobId(skillName, job_id);
+            // Re-mirror deliverables: copy archive deliverables to root if they exist
+            const docsDir = path.join(workspaceDir, '.docs', skillName);
+            const archiveDir = path.join(docsDir, 'jobs', job_id);
+            let mirroredCount = 0;
+            if (fs.existsSync(archiveDir)) {
+                const files = fs.readdirSync(archiveDir);
+                for (const file of files) {
+                    const src = path.join(archiveDir, file);
+                    if (fs.statSync(src).isFile()) {
+                        const dest = path.join(docsDir, file);
+                        fs.copyFileSync(src, dest);
+                        mirroredCount++;
+                    }
+                }
+            }
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            skill: skillName,
+                            activeJobId: job_id,
+                            status: job.status,
+                            currentState: job.currentState,
+                            mirroredDeliverables: mirroredCount,
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (err) {
+            return {
+                content: [{ type: 'text', text: JSON.stringify({ error: err.message }) }],
+                isError: true,
+            };
+        }
+    });
+    // 11. TOOL: reactive_archive_job
+    server.tool('reactive_archive_job', 'Archive an execution job for a reactive skill and rotate active pointer if archived was active', {
+        skill: z.string().optional().describe('Name of the reactive skill (defaults to active skill)'),
+        job_id: z.string().optional().describe('Job ID to archive (defaults to active job)'),
+    }, async ({ skill, job_id }) => {
+        try {
+            const skillName = skill || defaultSkill;
+            const jobManager = new JobManager(workspaceDir);
+            const targetId = job_id || jobManager.getActiveJobId(skillName);
+            const currentActive = jobManager.getActiveJobId(skillName);
+            const job = jobManager.getJob(skillName, targetId);
+            if (!job) {
+                return {
+                    content: [{ type: 'text', text: JSON.stringify({ error: `Job '${targetId}' not found for skill '${skillName}'` }) }],
+                    isError: true,
+                };
+            }
+            jobManager.updateJob(skillName, targetId, {
+                status: 'archived',
+                completedAt: new Date().toISOString(),
+            });
+            let freshJobId = currentActive;
+            if (currentActive === targetId) {
+                const freshJob = jobManager.createJob(skillName, { setActive: true });
+                freshJobId = freshJob.id;
+            }
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            skill: skillName,
+                            archivedJobId: targetId,
+                            status: 'archived',
+                            activeJobId: freshJobId,
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (err) {
+            return {
+                content: [{ type: 'text', text: JSON.stringify({ error: err.message }) }],
+                isError: true,
+            };
+        }
+    });
     // RESOURCE 1: reactive://events
     server.resource('reactive-events', 'reactive://events', async (uri) => {
         const store = new EventStore({ enableSqlite: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reactive-skills/runtime",
-  "version": "0.3.0",
+  "version": "0.4.1",
   "description": "Reactive Skills Architecture (RSA) core runtime — FSM engine, event store, guard evaluator, projection engine, MCP server",
   "type": "module",
   "main": "dist/index.js",
@@ -14,7 +14,8 @@
     "reactive-skills-mcp": "./dist/mcp/server.js"
   },
   "files": [
-    "dist"
+    "dist",
+    "CHANGELOG.md"
   ],
   "keywords": [
     "ai",