@programinglive/dev-workflow-mcp-server 1.13.0 → 1.13.1

package/db/adapters/base.js

@@ -1,6 +1,26 @@
 import { assertSafeKnowledge } from '../../security/policy.js';
 import { securityOutputFilter } from '../../security/sanitizer.js';
 
+/**
+ * Nilai `task_type` yang selalu boleh masuk kolom NOT NULL.
+ *
+ * MENGAPA ADA
+ * -----------
+ * Kolom `workflow_history.task_type` adalah NOT NULL, tetapi entri history
+ * yang lebih tua tidak selalu punya nilainya: penanda `dropped` versi lama
+ * ditulis tanpa `taskType` sama sekali, dan sebagian entri `forced` menyimpan
+ * string kosong. Saat `undefined` di-bind, driver mengubahnya menjadi NULL dan
+ * SQLite menolak dengan `NOT NULL constraint failed: workflow_history.task_type`.
+ *
+ * Dulu kegagalan itu membatalkan seluruh `syncToDatabase()`: ringkasan proyek
+ * dan state workflow ikut tidak pernah ditulis, jadi riwayat proyek diam-diam
+ * berhenti tersimpan. Normalisasi di sini membuat data lama tetap dapat
+ * disinkronkan tanpa menebak isi aslinya.
+ */
+export function normalizeTaskType(value) {
+    return typeof value === 'string' && value.trim() !== '' ? value.trim() : 'other';
+}
+
 export class DbAdapter {
     constructor(config = {}) {
         this.config = config;

package/db/adapters/mysql.js

@@ -1,5 +1,5 @@
 import mysql from "mysql2/promise";
-import { DbAdapter } from "./base.js";
+import { DbAdapter, normalizeTaskType } from "./base.js";
 import { assertSafeKnowledge, classify } from '../../security/policy.js';
 
 const FREQUENCY_FORMATS = {
@@ -106,7 +106,7 @@ export class MysqlAdapter extends DbAdapter {
             userId,
             normalizedProjectPath,
             entry.taskDescription,
-            entry.taskType,
+            normalizeTaskType(entry.taskType),
             entry.commitMessage,
             this.formatDate(entry.timestamp),
             entry.forced ? 1 : 0,

package/db/adapters/postgres.js

@@ -1,5 +1,5 @@
 import pg from "pg";
-import { DbAdapter } from "./base.js";
+import { DbAdapter, normalizeTaskType } from "./base.js";
 import { assertSafeKnowledge, classify } from '../../security/policy.js';
 
 const { Pool } = pg;
@@ -141,7 +141,7 @@ export class PostgresAdapter extends DbAdapter {
             numericUserId,
             normalizedProjectPath,
             entry.taskDescription || entry.description,
-            entry.taskType,
+            normalizeTaskType(entry.taskType),
             entry.commitMessage,
             entry.timestamp || entry.completed_at || new Date().toISOString(),
             entry.forced || false,

package/db/adapters/sqlite.js

@@ -2,7 +2,7 @@ import { safeLog } from '../../security/sanitizer.js';
 import Database from "better-sqlite3";
 import { existsSync } from "fs";
 import path from "path";
-import { DbAdapter } from "./base.js";
+import { DbAdapter, normalizeTaskType } from "./base.js";
 import { assertSafeKnowledge, classify } from '../../security/policy.js';
 
 const DB_FILENAME = "dev-workflow.db";
@@ -166,7 +166,7 @@ export class SqliteAdapter extends DbAdapter {
             userId,
             normalizedProjectPath,
             entry.taskDescription,
-            entry.taskType,
+            normalizeTaskType(entry.taskType),
             entry.commitMessage,
             entry.timestamp || new Date().toISOString(),
             entry.forced ? 1 : 0,

package/package.json

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

package/tools/handler-modules/index.js

@@ -269,8 +269,9 @@ export async function handleToolCall(context) {
     if(error) return securityOutputFilter(textResponse(error));
     assertSafeKnowledge({tool:context.request.params.name,args});
     assertSafeToolCommand(context.request.params.name,args);
+    if (context.workflowState) context.workflowState.lastConflict = null;
     const response=await dispatchToolCall({...context,request:{...context.request,params:{...context.request.params,arguments:args}}});
-    return securityOutputFilter(response);
+    return securityOutputFilter(withConflictNotice(response, context.workflowState));
   } catch(error) {
     if(['SECRET_CONTENT_DENIED','UNSAFE_COMMAND_DENIED'].includes(error.code)) {
       return {isError:true,content:[{type:'text',text:JSON.stringify({error:error.code,message:error.message,findings:error.findings})}]};
@@ -279,3 +280,35 @@ export async function handleToolCall(context) {
     return {isError:true,content:[{type:'text',text:'⚠️ Internal server error while processing the tool request.'}]};
   }
 }
+
+/**
+ * Tempelkan peringatan bila penyimpanan terakhir kalah dari proses lain.
+ *
+ * Tanpa ini, tool menjawab "berhasil" untuk state yang sebenarnya tidak
+ * tersimpan. Kejadian 29 Okt 2026: `start_task` menjawab "✅ Task Started",
+ * tetapi `get_workflow_status` berikutnya menampilkan task lain.
+ */
+function withConflictNotice(response, workflowState) {
+  const conflict = workflowState?.lastConflict;
+  if (!conflict) {
+    return response;
+  }
+  const text = response?.content?.[0]?.text;
+  if (typeof text !== "string") {
+    return response;
+  }
+  // Peringatan ditaruh DI DEPAN, dan menyebut terus terang bahwa aksi tadi
+  // tidak berlaku. Menempelkan "✅ berhasil" di atas peringatan membuat agen
+  // membaca baris pertama lalu melanjutkan seolah semuanya tersimpan.
+  const notice =
+    `⚠️ AKSI TIDAK BERLAKU - proses MCP lain memulai task yang lebih baru.\n` +
+    `   Task di disk : "${conflict.diskTask}"\n` +
+    `   Task Anda    : "${conflict.staleTask || '(kosong)'}"\n` +
+    `   State Anda sudah dimuat ulang dari disk, jadi langkah berikutnya mengikuti task di disk.\n` +
+    `   Jalankan ulang aksi ini bila memang untuk task tersebut, atau 'start_task' untuk menggantinya.\n\n` +
+    `--- pesan asli tool (TIDAK tersimpan) ---\n`;
+  return {
+    ...response,
+    content: [{ ...response.content[0], text: notice + text }, ...response.content.slice(1)],
+  };
+}

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

@@ -17,7 +17,10 @@ export async function handleStartTask(args, workflowState) {
   workflowState.state.commitAndPushCompleted = false;
   workflowState.state.lastCommitMessage = "";
   workflowState.state.lastPushBranch = "";
-  const reconciled = await workflowState.save();
+  // start_task memang bermaksud MENGGANTI task, jadi ia boleh menang atas
+  // task berjalan. Task yang diganti tetap diarsipkan oleh reconcileWithDisk,
+  // bukan dihapus.
+  const reconciled = await workflowState.save({ allowReplaceRunningTask: true });
 
   const warnings = [];
   const preservedForeign = reconciled?.preservedTask || preservedBeforeSave?.preservedTask;

package/workflow-state.js

@@ -560,6 +560,13 @@ export class WorkflowState {
     // History milik proyek, state milik sesi. Dalam tata letak nyata keduanya
     // berkas berbeda; untuk path eksplisit keduanya menunjuk berkas yang sama.
     this.historyFile = resolveHistoryFile(stateFilePath);
+    // Task yang terakhir kita baca dari / tulis ke disk. Dipakai untuk
+    // membedakan "task ini milik kita" dari "task ini ditulis proses lain
+    // sesudah kita memuat" - tanpa ini penulis basi menang tanpa perlawanan.
+    this.loadedTask = "";
+    // Konflik penyimpanan terakhir, dibaca oleh lapisan tool untuk memberi tahu
+    // pengguna. Null berarti penyimpanan terakhir aman.
+    this.lastConflict = null;
     this.state = {
       currentPhase: "idle",
       classification: "INTERNAL",
@@ -643,6 +650,7 @@ export class WorkflowState {
       // Run this as non-blocking to speed up startup
       ensureCompatibilityLinks(this.stateFile).catch(() => { });
       await this.mergeSharedHistory();
+      this.loadedTask = this.state.taskDescription || "";
       if (typeof this.state.testsCreated !== "boolean") {
         this.state.testsCreated = false;
       }
@@ -766,10 +774,25 @@ export class WorkflowState {
     return created;
   }
 
-  async save() {
+  async save(options = {}) {
     assertSafeKnowledge(this.state);
     const reconciled = await this.reconcileWithDisk();
     assertSafeKnowledge(this.state);
+
+    // Penulis basi tidak boleh menang.
+    //
+    // Bug 29 Okt 2026: satu proses MCP memegang state lama, lalu menyimpan
+    // sesudah proses lain memulai task baru. Task baru tertimpa dan pemanggil
+    // tetap diberi tahu "berhasil" - `get_workflow_status` berikutnya
+    // menampilkan task yang sama sekali lain.
+    const conflict = this.detectStaleOverwrite(reconciled, options);
+    if (conflict) {
+      await this.adoptDiskState();
+      this.lastConflict = conflict;
+      return { ...reconciled, conflict, verified: false };
+    }
+    this.lastConflict = null;
+
     this.state.owner = {
       processMarker: PROCESS_TOKEN,
       pid: process.pid,
@@ -783,9 +806,82 @@ export class WorkflowState {
     await this.updateProjectSummary();
     await this.syncToDatabase();
     this.lastReconcile = reconciled;
+    this.loadedTask = this.state.taskDescription || "";
+    await this.verifyPersisted(this.loadedTask);
     return reconciled;
   }
 
+  /**
+   * Apakah penyimpanan ini akan menimpa task berjalan milik proses lain?
+   *
+   * Konflik hanya kalau SEMUA ini benar:
+   *   - disk memuat task yang SEDANG berjalan (bukan idle),
+   *   - task di disk bukan task yang terakhir kita muat (jadi ditulis orang
+   *     lain sesudah kita membaca),
+   *   - task di disk bukan task yang akan kita tulis (jadi bukan kita sendiri),
+   *   - pemanggil tidak menyatakan maksud mengganti task.
+   *
+   * `start_task` memang bermaksud mengganti task, jadi ia memakai
+   * `allowReplaceRunningTask: true` dan tetap menang - tetapi task yang diganti
+   * diarsipkan oleh `reconcileWithDisk`, bukan dihapus.
+   */
+  detectStaleOverwrite(reconciled, options = {}) {
+    if (options.allowReplaceRunningTask === true) {
+      return null;
+    }
+    const diskTask = reconciled?.diskTask || "";
+    const diskPhase = reconciled?.diskPhase || "idle";
+    if (!diskTask || diskPhase === "idle") {
+      return null;
+    }
+    if (diskTask === this.loadedTask) {
+      return null;
+    }
+    if (diskTask === (this.state.taskDescription || "")) {
+      return null;
+    }
+    return {
+      diskTask,
+      staleTask: this.state.taskDescription || "",
+      diskPhase,
+    };
+  }
+
+  /** Ambil state dari disk apa adanya, dengan history digabung, tanpa menulis. */
+  async adoptDiskState() {
+    const disk = await this.readDiskState();
+    if (!disk) {
+      return false;
+    }
+    const mergedHistory = this.state.history || [];
+    this.state = { ...disk, history: mergedHistory };
+    this.mergeDiskHistory(disk);
+    this.loadedTask = this.state.taskDescription || "";
+    return true;
+  }
+
+  /**
+   * Pastikan tulisan kita benar-benar bertahan.
+   *
+   * Tanpa ini, proses yang kalah balapan tetap melaporkan sukses. Lebih baik
+   * gagal terang-terangan daripada memberi tahu "berhasil" untuk state yang
+   * sudah ditimpa proses lain.
+   */
+  async verifyPersisted(expectedTask) {
+    const disk = await this.readDiskState();
+    if (!disk) {
+      return true;
+    }
+    const actual = disk.taskDescription || "";
+    if (actual !== (expectedTask || "")) {
+      throw new Error(
+        `State workflow tidak bertahan: yang ditulis "${expectedTask}" tetapi di disk "${actual}". ` +
+        `Proses MCP lain menimpanya. Muat ulang state sebelum melanjutkan.`
+      );
+    }
+    return true;
+  }
+
   /**
    * Baca isi berkas state APA ADANYA dari disk (bukan dari memori).
    * Mengembalikan null kalau belum ada / rusak.
@@ -840,12 +936,20 @@ export class WorkflowState {
    * pekerjaan resize docker-alma tidak pernah muncul di view_history.
    */
   async reconcileWithDisk() {
-    const result = { mergedHistory: 0, preservedTask: null, foreignToken: null };
+    const result = {
+      mergedHistory: 0,
+      preservedTask: null,
+      foreignToken: null,
+      diskTask: "",
+      diskPhase: "idle",
+    };
     const disk = await this.readDiskState();
     if (!disk) {
       return result;
     }
 
+    result.diskTask = disk.taskDescription || "";
+    result.diskPhase = disk.currentPhase || "idle";
     result.mergedHistory = this.mergeDiskHistory(disk);
 
     if (!this.isForeignWrite(disk)) {
@@ -897,24 +1001,44 @@ export class WorkflowState {
     await fs.writeFile(summaryPath, JSON.stringify(summary, null, 2));
   }
 
-  async syncToDatabase() {
+  /**
+   * Menyalin history, ringkasan, dan state ke database.
+   *
+   * `db` dapat diinjeksi untuk pengujian; pemanggil biasa tidak mengirimnya.
+   *
+   * Satu entri yang gagal TIDAK boleh menghentikan sisanya. Dulu kegagalan
+   * pertama (mis. entri lama tanpa `task_type`) membatalkan seluruh fungsi,
+   * sehingga `updateSummaryForUser` dan `saveState` ikut terlewat dan riwayat
+   * proyek diam-diam berhenti tersimpan sama sekali.
+   */
+  async syncToDatabase(options = {}) {
     assertSafeKnowledge(this.state);
-    try {
-      const { insertHistoryEntry, updateSummaryForUser, saveState } = await import("./db/index.js");
-      const userId = getCurrentUserId();
-      // projectRoot dipakai sebagai identitas proyek di database. Ditentukan
-      // lewat resolveProjectRootForState, bukan dengan menghitung `dirname`
-      // berkali-kali: jumlah itu hanya benar untuk satu kedalaman tertentu.
-      const projectRoot = resolveProjectRootForState(this.stateFile);
-
-      for (const entry of this.state.history || []) {
-        await insertHistoryEntry(userId, projectRoot, entry);
+    const db = options.db ?? (await import("./db/index.js"));
+    const userId = getCurrentUserId();
+    // projectRoot dipakai sebagai identitas proyek di database. Ditentukan
+    // lewat resolveProjectRootForState, bukan dengan menghitung `dirname`
+    // berkali-kali: jumlah itu hanya benar untuk satu kedalaman tertentu.
+    const projectRoot = resolveProjectRootForState(this.stateFile);
+
+    let skipped = 0;
+    for (const entry of this.state.history || []) {
+      try {
+        await db.insertHistoryEntry(userId, projectRoot, entry);
+      } catch (error) {
+        skipped++;
+        safeLog("error", "History entry skipped:", error.message);
       }
-      await updateSummaryForUser(userId, projectRoot);
-      await saveState(userId, projectRoot, this.state);
+    }
+    if (skipped > 0) {
+      safeLog("error", `History sync skipped ${skipped} entr${skipped === 1 ? "y" : "ies"}.`);
+    }
+
+    try {
+      await db.updateSummaryForUser(userId, projectRoot);
+      await db.saveState(userId, projectRoot, this.state);
     } catch (error) {
-      // Database sync failed; log it but don't crash
-      safeLog('error', "Database sync failed:", error.message);
+      // Ringkasan dan state tetap opsional: jangan pernah menggagalkan save().
+      safeLog("error", "Database sync failed:", error.message);
     }
   }