@programinglive/dev-workflow-mcp-server 1.5.0 → 1.5.1

package/docs/product/PRD.md

@@ -35,6 +35,7 @@ Developers need structured guidance to maintain disciplined workflows across pro
 - Offer aggregated project summaries (JSON artifacts, SQLite sync, optional web dashboard).
 - Guard release commands to ensure prerequisites are satisfied.
 - Support `run_full_workflow` for scripted execution of all steps with validation.
+- Web dashboard displays version dynamically from `package.json` via `/api/version` endpoint to stay in sync after releases.
 
 ## 8. Technical Considerations
 - Node.js (ESM) codebase leveraging `@modelcontextprotocol/sdk`.
@@ -42,6 +43,7 @@ Developers need structured guidance to maintain disciplined workflows across pro
 - Optional SQLite integration for history and summary caching.
 - Vite build pipeline for distribution bundle; source usage recommended for MCP.
 - Windows compatibility requirements (Python, Build Tools for native modules).
+- **Deployment options**: Local development, Netlify (static), Plesk (full-featured).
 
 ## 9. Success Metrics
 - ≥90% of workflow operations executed via MCP tools (vs. manual overrides).
@@ -50,8 +52,9 @@ Developers need structured guidance to maintain disciplined workflows across pro
 
 ## 10. Milestones
 1. **MVP**: Core workflow tools, state persistence, basic history (complete).
-2. **Enhancements**: Improved project root detection, compatibility mirrors, `run_full_workflow` automation (in progress).
-3. **Future**: Expanded dashboard analytics, customizable workflows, richer integrations.
+2. **Enhancements**: Improved project root detection, compatibility mirrors, `run_full_workflow` automation (complete).
+3. **v1.5.0**: Netlify deployment support for static web dashboard (complete).
+4. **Future**: Expanded dashboard analytics, customizable workflows, richer integrations.
 
 ## 11. Risks & Mitigations
 - **Risk**: Workflow feels overly prescriptive. **Mitigation**: Provide escape hatches (`force_complete_task`, `drop_task`) with audit trails.

package/docs/release-notes/RELEASE_NOTES.md

@@ -4,6 +4,100 @@ Authoritative history of user-visible changes for the Development Workflow MCP S
 
 ## Unreleased
 
+## 1.5.0 — 2025-12-02
+- See CHANGELOG for details.
+
+## 1.4.11 — 2025-12-01 — 🐛 Bug Fixes
+- move vite to dependencies to ensure build works on production (62fc4c0)
+- resolve sentry permission issues (c739f8e)
+
+## 1.4.10 — 2025-12-01 — ✨ Features
+- **dashboard:** implement random data generation for analytics chart (17e2073)
+- move dompdf to require and resolve debugbar production error (e5d1cb6)
+
+## 1.4.9 — 2025-11-30 — ♻️ Refactors
+- **dashboard:** combine analytics charts and use local Chart.js (86ed3f4)
+
+## 1.4.8 — 2025-11-30 — 🐛 Bug Fixes
+- **dashboard:** improve responsive layout for admin stats cards (33d5b39)
+- **dashboard:** improve responsive layout for admin stats cards (530400d)
+
+## 1.4.7 — 2025-11-29 — ✨ Features
+- add core doc types (PRD/README/RELEASE_NOTES) and fix CI build (8ed0567)
+- update hero text and meta description to emphasize Indonesian programmer community (681547b)
+- display dynamic version in web dashboard from /api/version (69f561d)
+- add 1.4.3 release notes (8b165f7)
+- add MCP registry metadata (mcpName & server.json) (66caea1)
+- align MCP registry schema and docs (e4e732d)
+- **release:** 1.4.4 🚀 (05a968f)
+- **release:** 1.4.5 🚀 (7e823b9)
+- **release:** 1.4.6 🚀 (7e0b672)
+
+## 1.4.6 — 2025-11-27 — 🧹 Chores
+- add MCP registry metadata (mcpName & server.json) (66caea1)
+
+## 1.4.5 — 2025-11-27 — 🐛 Bug Fixes
+- display dynamic version in web dashboard from /api/version (69f561d)
+
+## 1.4.4 — 2025-11-27 — ♻️ Refactors
+- consolidate workflow state to root .state folder only (3d69a14)
+- ensure release guard uses freshest workflow state (e07eb42)
+- remove invalid turbopack experimental config from next.config.ts (af0a7ea)
+- **web:** configure next.js root to silence warnings (22ed002)
+- **web:** improve mobile layout for hero section (53b26bf)
+- add Plesk deployment guide (de35675)
+- add 1.4.3 release notes (8b165f7)
+- fix release state detection (ed5dfd1)
+- prepare for release (a6ea2d0)
+- **release:** 1.4.2 (fac8999)
+- **release:** 1.4.2 🚀 (01b0b3c)
+- **release:** 1.4.3 🚀 (04d8c3b)
+- update task list (35663dd)
+- **web:** fix next.js lockfile warning (05ffce0)
+- add core doc types (PRD/README/RELEASE_NOTES) and fix CI build (8ed0567)
+- update hero text and meta description to emphasize Indonesian programmer community (681547b)
+- update program tracks and fix fast refresh warning (aa5bc9c)
+
+## 1.4.3 — 2025-11-27 — 🧹 Chores
+- **release:** 1.4.2 (fac8999)
+- remove invalid turbopack experimental config from next.config.ts (af0a7ea)
+- add Plesk deployment guide (de35675)
+- update program tracks and fix fast refresh warning (aa5bc9c)
+
+## 1.4.2 — 2025-11-27 — 🧹 Chores
+- fix release state detection (ed5dfd1)
+- prepare for release (a6ea2d0)
+- update task list (35663dd)
+- **web:** fix next.js lockfile warning (05ffce0)
+- ensure release guard uses freshest workflow state (e07eb42)
+- **web:** configure next.js root to silence warnings (22ed002)
+- **web:** improve mobile layout for hero section (53b26bf)
+- consolidate workflow state to root .state folder only (3d69a14)
+
+## 1.4.1 — 2025-11-27 — 🐛 Bug Fixes
+- update build test to include postbuild (b1e2f48)
+- add custom server.js for Plesk (b3912cd)
+- migrate dashboard to Next.js with TypeScript and Tailwind CSS (bce1fec)
+- fix package.json scripts (fb25e98)
+- fix tsconfig and remove dist artifact (282759f)
+
+## 1.4.0 — 2025-11-26
+- See CHANGELOG for details.
+
+## 1.3.11 — 2025-11-23
+- Re-applied Plesk security fix (moved static files to `web/public/`).
+- Updated build configuration and server paths.
+
+## 1.3.10 — 2025-11-23
+- Fixed workflow state synchronization issue that caused forced releases.
+- Added `docs/WORKFLOW-BEST-PRACTICES.md`.
+
+## 1.3.9 — 2025-11-23
+- Improved documentation modal layout and readability.
+
+## 1.3.8 — 2025-11-23
+- Fixed documentation loading in production by tracking `dist/docs` in git.
+
 ## 1.3.0 — 2025-11-22
 - Added comprehensive Antigravity integration documentation and examples.
 - Fixed Windows shell escaping for commit messages.

package/docs/web-dashboard.md

@@ -156,8 +156,20 @@ Returns an array of task counts grouped by period.
 | Dashboard shows empty data | Confirm the MCP server has generated `.state/users/<user>/workflow-state.json` and that the chosen `user` matches. |
 | Port already in use | Set `DEV_WORKFLOW_WEB_PORT` to a free port before running `npm run web`. |
 
+## Deployment Options
+
+The web dashboard can be deployed in multiple ways:
+
+| Platform | Database Support | Best For |
+| --- | --- | --- |
+| Local (`npm run web`) | Full SQLite | Development and personal use |
+| [Netlify](./NETLIFY_DEPLOYMENT.md) | Static only | Public documentation site |
+| [Plesk](./PLESK_DEPLOYMENT.md) | Full SQLite | Self-hosted production |
+
 ## Related Topics
 
 - [Main README](../README.md)
+- [Netlify Deployment](./NETLIFY_DEPLOYMENT.md)
+- [Plesk Deployment](./PLESK_DEPLOYMENT.md)
 - [Workflow State Internals](./state.md) *(coming soon)*
 - [CLI Tools](../README.md#🛠️-available-tools)

package/package.json

@@ -1,18 +1,20 @@
 {
   "name": "@programinglive/dev-workflow-mcp-server",
-  "version": "1.5.0",
+  "version": "1.5.1",
   "description": "MCP server to enforce development workflow discipline",
   "homepage": "https://devworkflow.programinglive.com/",
+  "mcpName": "io.github.programinglive/dev-workflow-mcp-server",
   "type": "module",
   "main": "index.js",
   "bin": {
     "dev-workflow-mcp": "index.js"
   },
   "scripts": {
-    "build": "vite build",
-    "build:web": "npx tailwindcss -i ./web/public/input.css -o ./web/public/output.css --minify",
-    "watch:web": "npx tailwindcss -i ./web/public/input.css -o ./web/public/output.css --watch",
-    "postbuild": "npm run build:web && node scripts/build-docs.js",
+    "build": "npm run build:server && npm run build:web",
+    "build:server": "vite build",
+    "build:web": "npm run build --prefix web",
+    "watch:web": "npm run dev --prefix web",
+    "postbuild": "node scripts/build-docs.js",
     "dev": "node --watch index.js",
     "start": "node index.js",
     "local": "node index.js",
@@ -24,7 +26,7 @@
     "release:major": "node release-wrapper.js major",
     "release:minor": "node release-wrapper.js minor",
     "release:patch": "node release-wrapper.js patch",
-    "web": "node web/server.js"
+    "web": "npm start --prefix web"
   },
   "keywords": [
     "mcp",

package/release-wrapper.js

@@ -3,9 +3,71 @@
 import { spawn } from 'node:child_process';
 import fs from 'node:fs/promises';
 import path from 'node:path';
+import { resolveStateFile } from './workflow-state.js';
 
 const RELEASE_TYPES = new Set(['major', 'minor', 'patch']);
 
+async function readStateCandidate(filePath) {
+  if (!filePath) {
+    return null;
+  }
+
+  try {
+    const [raw, stats] = await Promise.all([fs.readFile(filePath, 'utf8'), fs.stat(filePath)]);
+    return {
+      state: JSON.parse(raw),
+      path: filePath,
+      mtimeMs: stats.mtimeMs,
+    };
+  } catch {
+    return null;
+  }
+}
+
+async function loadWorkflowStateCandidates(projectRoot) {
+  const candidates = [];
+
+  try {
+    candidates.push(resolveStateFile());
+  } catch {
+    // resolver may throw before state exists; fall through to other candidates
+  }
+
+  const legacyStatePath = path.join(projectRoot, '.state', 'workflow-state.json');
+  candidates.push(legacyStatePath);
+
+  // Add explicit DEV_WORKFLOW_STATE_FILE if provided (resolver would have used it, but keep explicit just in case)
+  if (process.env.DEV_WORKFLOW_STATE_FILE) {
+    candidates.push(path.resolve(process.env.DEV_WORKFLOW_STATE_FILE));
+  }
+
+  const seen = new Set();
+  let freshest = null;
+
+  for (const candidate of candidates) {
+    if (!candidate) {
+      continue;
+    }
+
+    const resolved = path.resolve(candidate);
+    if (seen.has(resolved)) {
+      continue;
+    }
+    seen.add(resolved);
+
+    const result = await readStateCandidate(resolved);
+    if (!result) {
+      continue;
+    }
+
+    if (!freshest || result.mtimeMs > freshest.mtimeMs) {
+      freshest = result;
+    }
+  }
+
+  return freshest;
+}
+
 async function main() {
   const releaseTypeArg = (process.argv[2] || '').toLowerCase();
   const forceFlag = process.argv.includes('--force') || process.env.DEV_WORKFLOW_FORCE_RELEASE === '1';
@@ -26,44 +88,17 @@ async function main() {
   }
   const projectRoot = projectRootCandidate;
 
-  // Prefer state under INIT_CWD to support per-project runs and tests.
-  // If DEV_WORKFLOW_USER_ID is set and a user-scoped file exists, use it; otherwise fall back to legacy path.
-  const baseStateDir = path.join(projectRoot, '.state');
-  const legacyStatePath = path.join(baseStateDir, 'workflow-state.json');
-  let resolvedUserId = (process.env.DEV_WORKFLOW_USER_ID || '').trim();
-  if (!resolvedUserId) {
-    try {
-      const fileUserId = (await fs.readFile(path.join(baseStateDir, 'user-id'), 'utf8')).trim();
-      if (fileUserId) {
-        resolvedUserId = fileUserId;
-      }
-    } catch {
-      // no user-id file; legacy layout likely
-    }
-  }
-  const userStatePath = resolvedUserId ? path.join(baseStateDir, 'users', resolvedUserId, 'workflow-state.json') : null;
-
-  let statePath = legacyStatePath;
-  if (userStatePath) {
-    try {
-      await fs.access(userStatePath);
-      statePath = userStatePath;
-    } catch {
-      // fall back to legacy path
-    }
-  }
-  let state;
-
-  try {
-    const raw = await fs.readFile(statePath, 'utf8');
-    state = JSON.parse(raw);
-  } catch (error) {
+  const result = await loadWorkflowStateCandidates(projectRoot);
+  if (!result) {
     console.error(
-      `❌ Release guard: cannot locate workflow state at ${statePath}. Make sure the dev-workflow MCP is installed and you have started a task.`
+      `❌ Release guard: cannot locate workflow state under ${path.join(projectRoot, '.state')}.
+Make sure the dev-workflow MCP is installed and you have started a task.`
     );
     process.exit(1);
   }
 
+  const { state, path: statePath } = result;
+
   const errors = [];
   if (state.currentPhase !== 'release') {
     errors.push(

package/scripts/update-release-notes.cjs

@@ -67,33 +67,29 @@ function updateReleaseNotes({
 
 function insertReleaseNotesEntry({ content, version, releaseDate, highlight, sectionHeading, detailBullets }) {
   const lines = content.split('\n');
-  const headerSeparatorIndex = lines.findIndex((line) => line.trim().startsWith('|---------'));
-  if (headerSeparatorIndex === -1) {
-    throw new Error('Unable to locate release notes table header.');
-  }
 
-  const newRow = `| ${version} | ${releaseDate} | ${escapePipes(highlight)} |`;
-  lines.splice(headerSeparatorIndex + 1, 0, newRow);
+  // Find the "## Unreleased" section
+  const unreleasedIndex = lines.findIndex((line) => line.trim().startsWith('## Unreleased'));
+  if (unreleasedIndex === -1) {
+    throw new Error('Unable to locate "## Unreleased" section in release notes.');
+  }
 
   const sectionLines = [];
   sectionLines.push('');
   const trimmedHeading = typeof sectionHeading === 'string' ? sectionHeading.trim() : '';
-  const headingSuffix = trimmedHeading ? ` – ${trimmedHeading}` : '';
-  sectionLines.push(`## ${version}${headingSuffix}`);
-  sectionLines.push('');
-  sectionLines.push(`Released on **${releaseDate}**.`);
-  sectionLines.push('');
+  const headingSuffix = trimmedHeading ? ` — ${trimmedHeading}` : '';
+
+  // Format: ## [Version] — [Date]
+  sectionLines.push(`## ${version} — ${releaseDate}${headingSuffix}`);
+
   for (const bullet of detailBullets) {
     sectionLines.push(`- ${bullet}`);
   }
-  sectionLines.push('');
 
-  const firstSectionIndex = lines.findIndex((line, idx) => idx > headerSeparatorIndex && line.startsWith('## '));
-  if (firstSectionIndex === -1) {
-    lines.push(...sectionLines);
-  } else {
-    lines.splice(firstSectionIndex, 0, ...sectionLines);
-  }
+  // Insert after the Unreleased header (and potentially some blank lines)
+  // We want to keep "## Unreleased" empty and add the new version below it.
+  // So we insert after the Unreleased line.
+  lines.splice(unreleasedIndex + 1, 0, ...sectionLines);
 
   return lines.join('\n');
 }

package/server.json

@@ -0,0 +1,23 @@
+{
+  "$schema": "https://static.modelcontextprotocol.io/schemas/2025-10-17/server.schema.json",
+  "name": "io.github.programinglive/dev-workflow-mcp-server",
+  "description": "MCP server to enforce development workflow discipline",
+  "title": "Dev Workflow MCP Server",
+  "websiteUrl": "https://devworkflow.programinglive.com/",
+  "repository": {
+    "url": "https://github.com/programinglive/dev-workflow-mcp-server",
+    "source": "github"
+  },
+  "version": "1.4.6",
+  "packages": [
+    {
+      "registryType": "npm",
+      "registryBaseUrl": "https://registry.npmjs.org",
+      "identifier": "@programinglive/dev-workflow-mcp-server",
+      "version": "1.4.6",
+      "transport": {
+        "type": "stdio"
+      }
+    }
+  ]
+}

package/tailwind.config.js

@@ -1,8 +1,6 @@
 /** @type {import('tailwindcss').Config} */
-export default {
-    content: [
-        "./web/public/**/*.{html,js}",
-    ],
+module.exports = {
+    content: ["./web/public/**/*.{html,js}"],
     theme: {
         extend: {},
     },

package/tests/build.test.js

@@ -8,7 +8,7 @@ import path from 'path';
 const exec = promisify(execCallback);
 
 test('build generates dist/index.mjs file', async () => {
-  const { stderr } = await exec('npm run build');
+  const { stderr } = await exec('npm run build:server && npm run postbuild');
   // Allow the known vite warning about node:process
   const knownWarning = '[plugin vite:resolve] Module "node:process" has been externalized for browser compatibility';
   const tailwindOutput = '≈ tailwindcss';
@@ -43,6 +43,49 @@ test('build script exists in package.json', async () => {
   const content = await readFile(packagePath, 'utf-8');
   const pkg = JSON.parse(content);
 
-  assert.strictEqual(typeof pkg.scripts.build, 'string');
-  assert(pkg.scripts.build.includes('vite build'));
+  assert.strictEqual(typeof pkg.scripts['build:server'], 'string');
+  assert(pkg.scripts['build:server'].includes('vite build'));
+});
+
+test('Hero component fetches version dynamically', async () => {
+  const heroPath = path.join(process.cwd(), 'web', 'components', 'Hero.tsx');
+  const heroContent = await readFile(heroPath, 'utf-8');
+
+  // Verify no hardcoded version strings
+  assert(!heroContent.includes('v1.3.12'), 'Hero should not have hardcoded v1.3.12');
+  assert(!heroContent.includes('"1.3.12"'), 'Hero should not have hardcoded "1.3.12"');
+
+  // Verify it fetches from /api/version
+  assert(heroContent.includes('fetch("/api/version")'), 'Hero should fetch version from API');
+  assert(heroContent.includes('useState<string | null>(null)'), 'Hero should have version state');
+});
+
+test('Netlify deployment configuration exists', async () => {
+  const netlifyTomlPath = path.join(process.cwd(), 'web', 'netlify.toml');
+  await access(netlifyTomlPath);
+  
+  const content = await readFile(netlifyTomlPath, 'utf-8');
+  assert(content.includes('[build]'), 'netlify.toml should have build section');
+  assert(content.includes('npm run build'), 'netlify.toml should have build command');
+  assert(content.includes('@netlify/plugin-nextjs'), 'netlify.toml should use Next.js plugin');
+});
+
+test('Web package.json does not include better-sqlite3', async () => {
+  const webPackagePath = path.join(process.cwd(), 'web', 'package.json');
+  const content = await readFile(webPackagePath, 'utf-8');
+  const pkg = JSON.parse(content);
+  
+  assert(!pkg.dependencies['better-sqlite3'], 'Web should not depend on better-sqlite3 for Netlify compatibility');
+});
+
+test('API routes return static data for Netlify deployment', async () => {
+  const summaryRoutePath = path.join(process.cwd(), 'web', 'app', 'api', 'summary', 'route.ts');
+  const historyRoutePath = path.join(process.cwd(), 'web', 'app', 'api', 'history', 'route.ts');
+  
+  const summaryContent = await readFile(summaryRoutePath, 'utf-8');
+  const historyContent = await readFile(historyRoutePath, 'utf-8');
+  
+  // Verify no database imports
+  assert(!summaryContent.includes('from "@/lib/db"'), 'Summary route should not import from db');
+  assert(!historyContent.includes('from "@/lib/db"'), 'History route should not import from db');
 });

package/tests/handlers.test.js

@@ -40,6 +40,84 @@ function createRequest(name, args) {
   };
 }
 
+test("run_tests guidance mentions core documentation types", async () => {
+  await withWorkflowState(async (workflowState) => {
+    workflowState.state.bugFixed = true;
+    workflowState.state.testsCreated = true;
+    await workflowState.save();
+
+    const response = await handleToolCall({
+      request: createRequest("run_tests", {
+        passed: true,
+        testCommand: "npm test",
+      }),
+      normalizeRequestArgs,
+      workflowState,
+      exec: async () => ({ stdout: "" }),
+      git: {
+        hasWorkingChanges: async () => false,
+        hasStagedChanges: async () => false,
+        hasTestChanges: async () => true,
+        getStagedChanges: async () => [],
+        getCurrentBranch: async () => "main",
+        getPrimaryBranch: async () => "main",
+        getLastCommitMessage: async () => "",
+        workingTreeSummary: () => ({ hasChanges: false, lines: [] }),
+      },
+      utils,
+    });
+
+    const text = response.content[0].text;
+    assert.ok(
+      text.includes("create or update documentation using 'create_documentation'"),
+      "run_tests guidance should mention create or update documentation",
+    );
+    assert.ok(
+      text.includes('"PRD", "README", "RELEASE_NOTES"'),
+      "run_tests guidance should list core documentation types",
+    );
+  });
+});
+
+test("create_documentation accepts PRD and records created/updated message", async () => {
+  await withWorkflowState(async (workflowState) => {
+    workflowState.state.testsPassed = true;
+    await workflowState.save();
+
+    const response = await handleToolCall({
+      request: createRequest("create_documentation", {
+        documentationType: "PRD",
+        summary: "Updated PRD for documentation workflow expectations",
+      }),
+      normalizeRequestArgs,
+      workflowState,
+      exec: async () => ({ stdout: "" }),
+      git: {
+        hasWorkingChanges: async () => false,
+        hasStagedChanges: async () => false,
+        hasTestChanges: async () => true,
+        getStagedChanges: async () => [],
+        getCurrentBranch: async () => "main",
+        getPrimaryBranch: async () => "main",
+        getLastCommitMessage: async () => "",
+        workingTreeSummary: () => ({ hasChanges: false, lines: [] }),
+      },
+      utils,
+    });
+
+    assert.equal(workflowState.state.documentationCreated, true);
+    assert.equal(workflowState.state.documentationType, "PRD");
+    assert.equal(
+      workflowState.state.documentationSummary,
+      "Updated PRD for documentation workflow expectations",
+    );
+    assert.ok(
+      response.content[0].text.includes("Documentation created/updated!"),
+      "create_documentation response should mention created/updated",
+    );
+  });
+});
+
 test("commit_and_push commits changes and pushes", async () => {
   await withWorkflowState(async (workflowState) => {
     workflowState.state.readyToCommit = true;

package/tests/mcpRegistry.test.js

@@ -0,0 +1,65 @@
+import { test } from "node:test";
+import assert from "node:assert";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+
+const projectRoot = process.cwd();
+
+async function readJson(relativePath) {
+  const fullPath = path.join(projectRoot, relativePath);
+  const content = await readFile(fullPath, "utf-8");
+  return JSON.parse(content);
+}
+
+test("package.json includes mcpName for MCP registry", async () => {
+  const pkg = await readJson("package.json");
+
+  assert.strictEqual(
+    pkg.mcpName,
+    "io.github.programinglive/dev-workflow-mcp-server",
+    "package.json should declare mcpName matching the MCP server namespace",
+  );
+});
+
+test("server.json is configured for npm package deployment", async () => {
+  const server = await readJson("server.json");
+
+  assert.strictEqual(
+    server.name,
+    "io.github.programinglive/dev-workflow-mcp-server",
+    "server.json name should match the MCP server namespace",
+  );
+  assert.ok(Array.isArray(server.packages) && server.packages.length > 0,
+    "server.json should declare at least one package entry",
+  );
+
+  const npmPkg = server.packages[0];
+
+  assert.strictEqual(
+    npmPkg.registryType,
+    "npm",
+    "First server.json package entry should use npm registryType",
+  );
+
+  assert.strictEqual(
+    npmPkg.registryBaseUrl,
+    "https://registry.npmjs.org",
+    "server.json npm registryBaseUrl should point at the public npm registry",
+  );
+
+  assert.strictEqual(
+    npmPkg.identifier,
+    "@programinglive/dev-workflow-mcp-server",
+    "server.json npm identifier should match the published npm package name",
+  );
+
+  assert.ok(
+    typeof npmPkg.version === "string" && npmPkg.version.length > 0,
+    "server.json npm package version should be a non-empty string",
+  );
+
+  assert.ok(
+    npmPkg.transport && npmPkg.transport.type === "stdio",
+    "server.json npm package transport should be stdio",
+  );
+});

package/tests/release-wrapper.test.js

@@ -18,6 +18,8 @@ async function runWrapper({ state, args = ["patch"], env = {} }) {
   const statePath = path.join(stateDir, "workflow-state.json");
   await mkdir(stateDir, { recursive: true });
   await writeFile(statePath, JSON.stringify(state, null, 2));
+  // Create package.json so resolveStateFile recognizes this as a project root
+  await writeFile(path.join(dir, "package.json"), JSON.stringify({ name: "test-project" }));
 
   const childEnv = {
     ...process.env,

package/tests/workflowState.test.js

@@ -67,14 +67,16 @@ test("resolveStateFile prefers current working directory when multiple project m
 
     const state = new TempWorkflowState();
     const resolvedStateFile = state.stateFile;
+    const resolvedProjectA = await realpath(projectA);
+    const resolvedProjectB = await realpath(projectB);
 
     assert.ok(
-      resolvedStateFile.startsWith(path.join(projectB, ".state", "users")),
+      resolvedStateFile.startsWith(path.join(resolvedProjectB, ".state", "users")),
       "State file should resolve under the current working directory's project"
     );
 
     assert.ok(
-      !resolvedStateFile.startsWith(path.join(projectA, ".state")),
+      !resolvedStateFile.startsWith(path.join(resolvedProjectA, ".state")),
       "State file should not use INIT_CWD project when cwd has its own markers"
     );
   } finally {
@@ -303,9 +305,11 @@ test("WorkflowState resolves state file relative to project root", async () => {
     if (devStateWasSet) {
       delete process.env.DEV_WORKFLOW_STATE_FILE;
     }
+    const resolvedProjectRoot = await realpath(projectRoot);
+
     const state = new WorkflowState();
     assert.ok(
-      state.stateFile.startsWith(path.join(projectRoot, ".state", "users")),
+      state.stateFile.startsWith(path.join(resolvedProjectRoot, ".state", "users")),
       "state file should resolve under project .state/users directory"
     );
 
@@ -314,7 +318,6 @@ test("WorkflowState resolves state file relative to project root", async () => {
     delete process.env.DEV_WORKFLOW_STATE_FILE;
 
     const state2 = new WorkflowState();
-    const resolvedProjectRoot = await realpath(projectRoot);
     assert.ok(
       state2.stateFile.startsWith(path.join(resolvedProjectRoot, ".state", "users")),
       "state file should resolve to project root"