@programinglive/dev-workflow-mcp-server 1.14.2 → 1.15.0

package/AGENTS.md

@@ -8,6 +8,8 @@ You are connected to the `dev-workflow` MCP server. **You MUST NOT perform any c
 Before taking any action or answering user requests regarding code changes, check your workflow status and follow these exact steps in sequence:
 
 1. **Start Task**: Call `start_task` with a clear description, type (`feature`, `bugfix`, `refactor`, or `other`), `projectDir`, **and a `definitionOfDone` checklist**. Every task must say, up front, which concrete conditions must be true before it counts as finished.
+
+   `start_task` **refuses** when another live MCP process is working the same project (heartbeat within the last 10 minutes). Two sessions on one working tree overwrite each other's files silently — on 31 October 2026 a session lost every edit in `tools/handler-modules/index.js` that way. Close the other window, use a git worktree, or pass `force: true` when you know the other session is idle. The check runs before any state is touched, so a refused call changes nothing.
 2. **Implement**: Write your code changes.
 3. **Mark Fixed**: Call `mark_bug_fixed` with a summary of the implementation.
 4. **Prove the Definition of Done**: For each item, call `mark_dod_item` with `evidence` (5-500 characters naming what you actually ran or checked, e.g. `npm test -> 505 pass`). An item that turned out not to apply is excluded with `waive_dod_item` and a written reason - never silently dropped.

package/README.md

@@ -688,7 +688,14 @@ applies: anything dirty blocks the release.
 
 ## Troubleshooting
 
-**`ERR_MODULE_NOT_FOUND: Cannot find package 'dotenv'`** — dependencies are not
+**`start_task` refuses because another session is working the same project.** A
+second session on one working tree silently overwrites the first session's files.
+Close the other OpenCode window, or give this session its own checkout with
+`git worktree add <path> -b <branch>` and run it from there. The check ignores
+locks with no heartbeat for 10 minutes, so a leftover MCP process does not block
+you; `force: true` overrides it when you know the other session is idle.
+
+**`ERR_MODULE_NOT_FOUND: Cannot find package 'dotenv'`** - dependencies are not
 installed. Run `npm install` in the repo.
 
 **`gyp ERR! find VS` on Windows** — the native module is compiling from source

package/index.js

@@ -14,7 +14,7 @@ import {
 } from "@modelcontextprotocol/sdk/types.js";
 import { fileURLToPath } from "url";
 import path from "path";
-import { acquireProcessLock, releaseProcessLock, lockWarning, projectLockDir } from "./process-lock.js";
+import { acquireProcessLock, releaseProcessLock, lockWarning, projectLockDir, refreshProcessLock, HEARTBEAT_MS } from "./process-lock.js";
 import { exec, setActiveProjectDir } from "./exec.js";
 import { normalizeRequestArgs, shellEscape } from "./utils.js";
 import { createGitFacade } from "./git-facade.js";
@@ -220,6 +220,16 @@ export async function main() {
     const warning = lockWarning(acquireProcessLock({ dir: lockDir }));
     if (warning) safeLog('error', warning);
     process.once('exit', () => releaseProcessLock({ dir: lockDir }));
+
+    // Detak jantung penanda proses.
+    //
+    // Tanpa ini, penanda hanya menyebut KAPAN proses start. Proses MCP yang
+    // tertinggal hidup setelah jendela OpenCode-nya ditutup akan terlihat sama
+    // hidupnya dengan sesi yang benar-benar bekerja, sehingga aturan "satu
+    // penulis per repo" tidak bisa ditegakkan tanpa memblokir sesi yang sah.
+    // Dengan detak, "hidup" berarti "hidup DAN baru saja bekerja".
+    const heartbeat = setInterval(() => refreshProcessLock(), HEARTBEAT_MS);
+    heartbeat.unref?.();
   } catch (lockError) {
     safeLog('error', 'Warning: could not record process lock:', lockError.message);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@programinglive/dev-workflow-mcp-server",
-  "version": "1.14.2",
+  "version": "1.15.0",
   "description": "MCP server to enforce development workflow discipline",
   "homepage": "https://devworkflow.programinglive.com/",
   "mcpName": "io.github.programinglive/dev-workflow-mcp-server",

package/process-lock.js

@@ -80,8 +80,7 @@ export function readProcessLock({ dir }) {
   }
 }
 
-function defaultIsAlive(pid) {
-  if (!Number.isFinite(pid) || pid <= 0) return false;
+function defaultIsAlive(pid) {  if (!Number.isFinite(pid) || pid <= 0) return false;
 
   try {
     // Sinyal 0 tidak mengirim apa pun; ia hanya memeriksa apakah proses ada.
@@ -111,12 +110,13 @@ export function acquireProcessLock({
   const existing = readProcessLock({ dir });
 
   if (existing && existing.pid !== pid && isAlive(existing.pid)) {
+    rememberLockDir(dir);
     return { acquired: false, holder: existing };
   }
 
   const tookOverFrom = existing && existing.pid !== pid ? existing.pid : undefined;
 
-  const payload = { pid, startedAt: now, host: safeHostname() };
+  const payload = { pid, startedAt: now, heartbeatAt: now, host: safeHostname() };
 
   try {
     mkdirSync(dir, { recursive: true });
@@ -133,8 +133,7 @@ export function acquireProcessLock({
     };
   }
 
-  return tookOverFrom ? { acquired: true, tookOverFrom } : { acquired: true };
-}
+  return tookOverFrom ? { acquired: true, tookOverFrom } : { acquired: true };}
 
 /** Melepas lock hanya bila memang milik kita. */
 export function releaseProcessLock({ dir, pid = process.pid }) {
@@ -189,3 +188,86 @@ export function lockWarning(result) {
     "memastikan hanya satu proses yang hidup."
   );
 }
+
+/**
+ * Berapa lama penanda proses dianggap masih "baru saja bekerja".
+ *
+ * Dipakai untuk membedakan sesi yang benar-benar aktif dari proses MCP yang
+ * tertinggal hidup setelah jendela OpenCode-nya ditutup. Tanpa batas ini,
+ * "satu penulis per repo" hanya bisa ditegakkan dengan memblokir sesi yang sah.
+ */
+export const DEFAULT_LOCK_STALE_MS = 10 * 60 * 1000;
+
+/** Interval detak jantung; sepertiga dari batas basi, supaya ada toleransi. */
+export const HEARTBEAT_MS = Math.floor(DEFAULT_LOCK_STALE_MS / 3);
+
+/** Direktori lock yang terakhir dipegang proses ini (diisi acquireProcessLock). */
+let rememberedLockDir = null;
+
+function lockStamp(lock) {
+  const value = Number(lock?.heartbeatAt ?? lock?.startedAt);
+  return Number.isFinite(value) ? value : 0;
+}
+
+/**
+ * Menyegarkan penanda milik kita sendiri.
+ *
+ * Mengembalikan false bila penanda bukan milik kita atau tidak bisa ditulis.
+ * Tidak pernah melempar: gagal menyegarkan penanda tidak boleh mematikan server,
+ * tetapi juga tidak boleh diam-diam dianggap berhasil.
+ */
+export function refreshProcessLock({ dir = rememberedLockDir, pid = process.pid, now = Date.now(), writeFileImpl = writeFileSync } = {}) {
+  if (!dir) return false;
+
+  const existing = readProcessLock({ dir });
+  if (!existing || existing.pid !== pid) return false;
+
+  try {
+    writeFileImpl(processLockPath({ dir }), JSON.stringify({ ...existing, heartbeatAt: now }), "utf8");
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Pemegang lock lain yang masih hidup DAN masih bekerja, atau null.
+ *
+ * Inilah yang membuat aturan "satu penulis per repo" punya gigi: pemanggil bisa
+ * menolak memulai pekerjaan alih-alih menimpanya. Penanda yang basi (tidak ada
+ * detak dalam `staleMs`) diabaikan, karena proses MCP yang tertinggal hidup
+ * bukan alasan memblokir sesi baru.
+ */
+export function activeForeignLock({
+  dir = rememberedLockDir,
+  pid = process.pid,
+  now = Date.now(),
+  staleMs = DEFAULT_LOCK_STALE_MS,
+  isAlive = defaultIsAlive,
+} = {}) {
+  if (!dir) return null;
+
+  const lock = readProcessLock({ dir });
+  if (!lock || lock.pid === pid) return null;
+  if (!isAlive(lock.pid)) return null;
+
+  const age = now - lockStamp(lock);
+  if (age > staleMs) return null;
+
+  return { ...lock, ageMs: age };
+}
+
+/** Mengingat direktori lock supaya detak jantung tidak perlu parameter. */
+export function rememberLockDir(dir) {
+  rememberedLockDir = dir || null;
+}
+
+/** Hanya untuk tes: mengganti pemeriksa "proses hidup". */
+let isAliveOverride = null;
+export function setIsAliveForTests(fn) {
+  isAliveOverride = typeof fn === "function" ? fn : null;
+}
+
+export function currentIsAlive() {
+  return isAliveOverride || defaultIsAlive;
+}

package/tools/definitions.js

@@ -44,6 +44,13 @@ export function getToolList() {
               "Each item must later be proven with 'mark_dod_item' (evidence required) or waived with " +
               "'waive_dod_item' (reason required). A task cannot be committed or closed while any item is open.",
           },
+          force: {
+            type: "boolean",
+            description:
+              "Start anyway when another live MCP process is working the same project. Only for the machine owner: " +
+              "two sessions on one working tree overwrite each other's files silently. Prefer closing the other " +
+              "session or using a git worktree.",
+          },
         },
         required: ["description", "type", "definitionOfDone"],
       },

package/tools/handler-modules/workflow-handlers.js

@@ -1,6 +1,7 @@
 import { classify } from '../../security/policy.js';
 import { textResponse, isReleaseSatisfied, isErrorResponse, ensurePrdExists } from "./shared.js";
 import { validateItemTexts } from "./dod.js";
+import { activeForeignLock, projectLockDir, currentIsAlive, DEFAULT_LOCK_STALE_MS } from "../../process-lock.js";
 import { resolveProjectDir, setActiveProjectDir } from "../../exec.js";
 
 /**
@@ -88,6 +89,46 @@ async function captureDirtyAtStart(git) {
 }
 
 export async function handleStartTask(args, workflowState, git) {
+  // Satu penulis per repo.
+  //
+  // 31 Oktober 2026 dua sesi OpenCode menulis satu working tree yang sama. Satu
+  // sesi kehilangan seluruh suntingannya di `tools/handler-modules/index.js`
+  // tanpa pesan apa pun: berkasnya kembali ke versi HEAD di tengah pekerjaan.
+  // Penanda proses sudah ada sejak sebelumnya, tetapi hanya DICATAT sebagai
+  // peringatan, jadi tidak ada yang menghentikan tabrakan.
+  //
+  // Sekarang `start_task` menolak memulai bila ada proses MCP lain yang hidup
+  // DAN baru saja bekerja (ada detak dalam 10 menit) pada proyek yang sama.
+  // Penanda yang basi diabaikan supaya proses MCP yang tertinggal tidak
+  // memblokir selamanya. `force: true` tetap tersedia untuk pemilik mesin yang
+  // tahu apa yang ia lakukan, dan alasannya dicatat di jawaban.
+  const foreignLock = activeForeignLock({
+    dir: projectLockDir(workflowState.stateFile),
+    isAlive: currentIsAlive(),
+  });
+
+  if (foreignLock && args.force !== true) {
+    const minutes = Math.max(1, Math.round(foreignLock.ageMs / 60000));
+    const host = foreignLock.host ? ` di ${foreignLock.host}` : "";
+    const started = Number.isFinite(Number(foreignLock.startedAt))
+      ? new Date(Number(foreignLock.startedAt)).toISOString()
+      : "waktu tidak diketahui";
+
+    return textResponse(
+      `⚠️ Dibatalkan: sesi lain sedang mengerjakan proyek ini.\n\n` +
+        `Proses MCP PID ${foreignLock.pid}${host} berdetak ${minutes} menit lalu ` +
+        `(hidup sejak ${started}).\n` +
+        `Dua sesi pada satu working tree saling menimpa berkas: pada 31 Oktober 2026 ` +
+        `satu sesi kehilangan seluruh suntingannya tanpa pesan.\n\n` +
+        `Pilih salah satu:\n` +
+        `  1. Tutup jendela OpenCode yang lain, lalu ulangi 'start_task'.\n` +
+        `  2. Beri sesi ini worktree sendiri: opencode.worktree_create, lalu jalankan sesi dari sana.\n` +
+        `  3. Kalau Anda yakin sesi itu sudah tidak dipakai, ulangi dengan { "force": true }.\n\n` +
+        `Penanda dianggap basi setelah ${Math.round(DEFAULT_LOCK_STALE_MS / 60000)} menit tanpa detak.\n` +
+        `Task BELUM dimulai; tidak ada state yang diubah.`
+    );
+  }
+
   // Validasi DoD SEBELUM menyentuh state apa pun. Task yang ditolak tidak boleh
   // mengganti task yang sedang berjalan, dan tidak boleh meninggalkan state
   // setengah jadi yang membuat `get_workflow_status` membingungkan.