@programinglive/dev-workflow-mcp-server 1.13.15 → 1.14.0

package/tools/handler-modules/dod.js

@@ -0,0 +1,335 @@
+/**
+ * Aturan Definition of Done, sebagai fungsi murni.
+ *
+ * Semua di sini sengaja tanpa MCP dan tanpa filesystem: aturan "kapan sebuah
+ * task benar-benar selesai" harus bisa dibaca dan diuji tanpa menyalakan
+ * server. Handler di `dod-handlers.js` hanya memvalidasi, mengubah state, lalu
+ * menyimpan.
+ *
+ * MENGAPA PER ITEM, BUKAN SATU TEKS
+ * ---------------------------------
+ * Factory menyimpan DoD sebagai teks checklist. Itu cukup untuk gerbang
+ * "tidak boleh kosong", tetapi tidak bisa membedakan "sudah dibuktikan" dari
+ * "ditulis lalu dilupakan". Di sini tiap item punya status sendiri, bukti
+ * sendiri, dan revisi saat ia dibuktikan.
+ */
+
+export const MAX_ITEMS = 20;
+export const MIN_TEXT = 3;
+export const MAX_TEXT = 300;
+export const MIN_EVIDENCE = 5;
+export const MAX_EVIDENCE = 500;
+
+const STATUSES = new Set(["open", "done", "waived"]);
+
+/** Peringkat status untuk penggabungan antar-proses: makin tinggi makin kuat. */
+const STATUS_RANK = { open: 0, waived: 1, done: 2 };
+
+function clampText(value, limit = MAX_TEXT) {
+  const text = String(value ?? "").trim();
+  return text.length > limit ? text.slice(0, limit) : text;
+}
+
+/**
+ * Validasi daftar teks DoD yang datang dari agen.
+ *
+ * Dipakai `start_task` dan `set_definition_of_done`. Menolak dengan pesan yang
+ * menyebut aturannya, bukan sekadar "invalid input", karena agen yang ditolak
+ * harus tahu persis apa yang harus diperbaiki.
+ */
+export function validateItemTexts(texts) {
+  if (!Array.isArray(texts)) {
+    return {
+      ok: false,
+      error:
+        "definitionOfDone harus berupa daftar teks, satu kondisi per item, " +
+        'contoh: ["build lulus", "halaman login terverifikasi"].',
+    };
+  }
+
+  if (texts.length === 0) {
+    return {
+      ok: false,
+      error:
+        "definitionOfDone wajib berisi minimal satu item: kondisi konkret yang harus " +
+        "benar sebelum task boleh dianggap selesai.",
+    };
+  }
+
+  if (texts.length > MAX_ITEMS) {
+    return {
+      ok: false,
+      error: `definitionOfDone maksimal ${MAX_ITEMS} item; dikirim ${texts.length}. Gabungkan kondisi yang sejenis.`,
+    };
+  }
+
+  const items = [];
+  const seen = new Map();
+
+  for (const [index, raw] of texts.entries()) {
+    const text = clampText(raw);
+
+    if (text === "") {
+      return { ok: false, error: `Item DoD ke-${index + 1} kosong. Setiap item harus berisi kondisi yang bisa dibuktikan.` };
+    }
+
+    if (text.length < MIN_TEXT) {
+      return {
+        ok: false,
+        error: `Item DoD "${text}" terlalu pendek (minimal ${MIN_TEXT} karakter). Tulis kondisi yang bisa diperiksa, contoh: "build lulus".`,
+      };
+    }
+
+    if (String(raw ?? "").trim().length > MAX_TEXT) {
+      return {
+        ok: false,
+        error: `Item DoD ke-${index + 1} lebih dari ${MAX_TEXT} karakter. Ringkas jadi satu kondisi.`,
+      };
+    }
+
+    const key = text.toLowerCase();
+    if (seen.has(key)) {
+      return {
+        ok: false,
+        error: `Item DoD "${text}" duplikat dengan item ke-${seen.get(key) + 1}. Setiap kondisi hanya boleh muncul sekali.`,
+      };
+    }
+    seen.set(key, index);
+    items.push(text);
+  }
+
+  return { ok: true, items };
+}
+
+/**
+ * Normalisasi state yang dibaca dari disk.
+ *
+ * Berbeda dari `validateItemTexts`: di sini tujuannya JANGAN gagal. Berkas state
+ * ditulis versi lama, atau oleh proses lain yang sedang berjalan; satu entri
+ * rusak tidak boleh membuat seluruh workflow tidak bisa dimuat. Entri yang tidak
+ * bisa diselamatkan dibuang, sisanya diperbaiki.
+ */
+export function normalizeItems(raw) {
+  if (!Array.isArray(raw)) {
+    return [];
+  }
+
+  const items = [];
+  const usedIds = new Set();
+
+  for (const entry of raw) {
+    const source = typeof entry === "string" ? { text: entry } : entry && typeof entry === "object" ? entry : null;
+    if (!source) continue;
+
+    const text = clampText(source.text);
+    if (text === "") continue;
+    if (items.length >= MAX_ITEMS) break;
+
+    let id = typeof source.id === "string" ? source.id.trim() : "";
+    if (id === "" || usedIds.has(id)) {
+      id = nextItemId(items.concat(Array.from(usedIds, (value) => ({ id: value }))));
+    }
+    usedIds.add(id);
+
+    const status = STATUSES.has(source.status) ? source.status : "open";
+    const revision = Number.isFinite(Number(source.revision)) && Number(source.revision) >= 0
+      ? Math.trunc(Number(source.revision))
+      : 0;
+
+    items.push({
+      id,
+      text,
+      status,
+      evidence: status === "done" ? clampText(source.evidence, MAX_EVIDENCE) : "",
+      waivedReason: status === "waived" ? clampText(source.waivedReason, MAX_EVIDENCE) : "",
+      revision,
+      updatedAt: typeof source.updatedAt === "string" ? source.updatedAt : "",
+    });
+  }
+
+  return items;
+}
+
+/**
+ * Membaca checklist papan Factory menjadi daftar teks.
+ *
+ * Butir `- [x]` tetap diimpor sebagai item BIASA (status `open` di sisi
+ * pemanggil): checklist papan adalah rencana kerja, bukan bukti. Kalau kotak
+ * centang papan dipercaya apa adanya, agen bisa mewarisi klaim orang lain tanpa
+ * pernah menjalankan apa pun di mesin ini.
+ */
+export function parseFactoryChecklist(text) {
+  const lines = String(text ?? "").split(/\r?\n/);
+  const items = [];
+  const seen = new Set();
+  let truncated = false;
+
+  for (const line of lines) {
+    if (items.length >= MAX_ITEMS) {
+      truncated = true;
+      break;
+    }
+
+    const trimmed = line.trim();
+    if (trimmed === "") continue;
+    if (/^#{1,6}\s/.test(trimmed)) continue;
+
+    const checkbox = trimmed.match(/^[-*+]\s*\[[ xX]\]\s*(.+)$/);
+    const bullet = checkbox ? null : trimmed.match(/^[-*+]\s+(.+)$/);
+    const captured = checkbox?.[1] ?? bullet?.[1];
+    if (!captured) continue;
+
+    let item = captured.trim();
+    if (item === "") continue;
+
+    if (item.length > MAX_TEXT) {
+      item = item.slice(0, MAX_TEXT);
+      truncated = true;
+    }
+
+    const key = item.toLowerCase();
+    if (seen.has(key)) {
+      truncated = true;
+      continue;
+    }
+    seen.add(key);
+    items.push(item);
+  }
+
+  return { items, truncated };
+}
+
+/**
+ * Apakah satu item sudah memenuhi syaratnya.
+ *
+ * Item `done` hanya memenuhi bila dibuktikan pada revisi yang sedang berlaku.
+ * Saat perubahan kerja baru muncul setelah commit, `dodRevision` naik dan bukti
+ * lama otomatis tidak lagi berlaku - tanpa perlu menulis ulang item mana pun.
+ * Item `waived` tetap memenuhi, karena waiver adalah keputusan, bukan bukti.
+ */
+export function isSatisfied(item, revision) {
+  if (!item) return false;
+  if (item.status === "waived") return true;
+  if (item.status !== "done") return false;
+  return Number(item.revision) === Number(revision);
+}
+
+function maxItemNumber(items) {
+  let max = 0;
+  for (const item of items) {
+    const match = /^dod-(\d+)$/.exec(String(item?.id ?? ""));
+    if (match) max = Math.max(max, Number(match[1]));
+  }
+  return max;
+}
+
+export function nextItemId(items) {
+  return `dod-${maxItemNumber(items) + 1}`;
+}
+
+export function openItems(items, revision) {
+  return (Array.isArray(items) ? items : []).filter((item) => !isSatisfied(item, revision));
+}
+
+export function summarize(items, revision) {
+  const list = Array.isArray(items) ? items : [];
+  const waivedReasons = [];
+  let done = 0;
+  let waived = 0;
+
+  for (const item of list) {
+    if (item.status === "waived") {
+      waived += 1;
+      if (item.waivedReason) waivedReasons.push(item.waivedReason);
+      continue;
+    }
+    if (isSatisfied(item, revision)) done += 1;
+  }
+
+  return {
+    total: list.length,
+    done,
+    waived,
+    open: list.length - done - waived,
+    waivedReasons,
+  };
+}
+
+/**
+ * Daftar item yang belum terpenuhi, LENGKAP dengan id-nya.
+ *
+ * `renderChecklist` sengaja hanya menampilkan kondisi (untuk dibaca manusia).
+ * Pesan penolakan butuh id, karena tanpa id agen tidak tahu item mana yang
+ * harus dibuktikan lewat `mark_dod_item`.
+ */
+export function renderOutstanding(items, revision) {
+  return openItems(items, revision)
+    .map((item) => {
+      const state = item.status === "done" ? "bukti basi, perlu konfirmasi ulang" : "terbuka";
+      return `- ${item.id} [${state}]: ${item.text}`;
+    })
+    .join("\n");
+}
+
+export function renderChecklist(items, revision) {  const list = Array.isArray(items) ? items : [];
+
+  return list
+    .map((item) => {
+      const text = String(item.text ?? "");
+      if (item.status === "waived") {
+        return `- [~] ${text} — dilewati: ${item.waivedReason || "(tanpa alasan)"}`;
+      }
+      if (item.status === "done" && !isSatisfied(item, revision)) {
+        return `- [!] ${text} — bukti basi, perlu konfirmasi ulang`;
+      }
+      if (item.status === "done") {
+        return `- [x] ${text} — bukti: ${item.evidence}`;
+      }
+      return `- [ ] ${text}`;
+    })
+    .join("\n");
+}
+
+/**
+ * Menggabungkan DoD milik proses ini dengan yang ada di disk.
+ *
+ * Dua proses MCP bisa melayani task yang sama. Kalau array digabung begitu saja
+ * dengan "yang terakhir menulis menang", proses yang memegang state basi akan
+ * menghapus bukti yang baru dicatat proses lain. Karena itu per id dipilih entri
+ * yang lebih kuat menurut (peringkat status, revisi), dan item yang hanya ada di
+ * salah satu sisi tetap dipertahankan.
+ */
+export function mergeDefinitionOfDone(memoryItems, diskItems) {
+  const memory = Array.isArray(memoryItems) ? memoryItems : [];
+  const disk = Array.isArray(diskItems) ? diskItems : [];
+
+  const stronger = (a, b) => {
+    const rankA = STATUS_RANK[a.status] ?? 0;
+    const rankB = STATUS_RANK[b.status] ?? 0;
+    if (rankA !== rankB) return rankA > rankB ? a : b;
+    return Number(a.revision) >= Number(b.revision) ? a : b;
+  };
+
+  const diskById = new Map();
+  for (const item of disk) {
+    if (item?.id) diskById.set(item.id, item);
+  }
+
+  const merged = [];
+  const seen = new Set();
+
+  for (const item of memory) {
+    if (!item?.id) continue;
+    seen.add(item.id);
+    const fromDisk = diskById.get(item.id);
+    merged.push(fromDisk ? stronger(item, fromDisk) : item);
+  }
+
+  for (const item of disk) {
+    if (!item?.id || seen.has(item.id)) continue;
+    seen.add(item.id);
+    merged.push(item);
+  }
+
+  return merged;
+}

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

@@ -1,4 +1,5 @@
 import { textResponse } from "./shared.js";
+import { parseFactoryChecklist } from "./dod.js";
 import { startKeeping, stopKeeping } from "../../session-keeper.js";
 import {
   readFactoryConfig,
@@ -141,15 +142,32 @@ export async function handleClaimFactoryTask(args = {}, { workflowState } = {})
     // ada entri history, tidak ada peringatan, tidak disebut di jawaban.
     // `start_task` sudah mengarsipkan sejak awal; claim tidak.
     let archivedTask = null;
+    // Checklist papan diimpor sebagai RENCANA, bukan bukti: setiap item masuk
+    // sebagai `open` walau di papan sudah dicentang. Centang di papan berarti
+    // seseorang pernah menyatakannya, bukan bahwa kode di mesin ini terbukti.
+    const importedDod = parseFactoryChecklist(task.definitionOfDone);
     if (workflowState) {
       const archived = workflowState.reset({
         archive: true,
         reason: "Diganti claim_factory_task sebelum task selesai",
       });
       archivedTask = archived?.archivedTask || null;
+      const now = new Date().toISOString();
       workflowState.state.currentPhase = "coding";
       workflowState.state.taskDescription = `[${task.taskKey || task.id}] ${task.title}`;
       workflowState.state.taskType = "other";
+      workflowState.state.definitionOfDone = importedDod.items.map((text, index) => ({
+        id: `dod-${index + 1}`,
+        text,
+        status: "open",
+        evidence: "",
+        waivedReason: "",
+        revision: 0,
+        updatedAt: now,
+      }));
+      workflowState.state.dodSource = importedDod.items.length > 0 ? "factory" : "";
+      workflowState.state.dodFactoryTaskId = importedDod.items.length > 0 ? recordId : "";
+      workflowState.state.dodRevision = 0;
       await workflowState.save();
     }
 
@@ -165,7 +183,15 @@ export async function handleClaimFactoryTask(args = {}, { workflowState } = {})
           : "",
         `Factory status is now running (work session ${session.id}).`,
         task.projectName ? `Project: ${task.projectName}` : "",
-        task.definitionOfDone ? `Definition of done:\n${task.definitionOfDone}` : "",
+        importedDod.items.length > 0
+          ? `Imported ${importedDod.items.length} definition-of-done item(s) from the board, all OPEN:\n` +
+            importedDod.items.map((text, index) => `   dod-${index + 1}: ${text}`).join("\n") +
+            (importedDod.truncated
+              ? "\n   (Some board items were shortened or dropped: at most 20 items of 300 characters are kept.)"
+              : "") +
+            "\n   Prove each one locally with 'mark_dod_item' { id, evidence }, or waive it with a reason."
+          : "This board task has no definition of done. Add one with 'set_definition_of_done' { items: [...] } - " +
+            "a task cannot be committed or closed without it.",
         "",
         "Local workflow started for this task.",
         "Use 'sync_task_status' with review, blocked or paused to close the session, or done to approve the task once it is in review.",

package/tools/handler-modules/index.js

@@ -10,6 +10,7 @@ import { handleSkipRelease, handlePerformRelease } from "./release-handlers.js";
 import { handleCommitAndPush, handleCompleteTask, handleForceCompleteTask, handleDropTask } from "./commit-handlers.js";
 import { handleProjectSummary, handleProjectSummaryData, handleProjectSummaryDb, handleViewHistory } from "./summary-handlers.js";
 import { handleGetWorkflowStatus, handleReadyCheck, handleContinueWorkflow, handleRerunWorkflow } from "./status-handlers.js";
+import { handleSetDefinitionOfDone, handleMarkDodItem, handleWaiveDodItem } from "./dod-handlers.js";
 import { handleListFactoryTasks, handleClaimFactoryTask, handleSyncTaskStatus, handleListFactoryProjects, handleCreateFactoryTask, handleUpdateFactoryTask } from "./factory-handlers.js";
 
 function summarizeResponse(label, response) {
@@ -197,6 +198,12 @@ async function dispatchToolCall({
       }
       case "start_task":
         return handleStartTask(args, workflowState);
+      case "set_definition_of_done":
+        return handleSetDefinitionOfDone(args, workflowState);
+      case "mark_dod_item":
+        return handleMarkDodItem(args, workflowState);
+      case "waive_dod_item":
+        return handleWaiveDodItem(args, workflowState);
       case "mark_bug_fixed":
         return handleMarkBugFixed(args, workflowState);
       case "create_feature_flow":

package/tools/handler-modules/shared.js

@@ -46,6 +46,11 @@ export async function resetToCommitIfWorkingChanges(workflowState, git) {
   workflowState.state.currentPhase = "commit";
   workflowState.state.releaseCommand = "";
   workflowState.state.releaseNotes = "";
+  // Perubahan kerja baru berarti bukti DoD yang lama tidak lagi membuktikan
+  // kode yang akan di-commit. Menaikkan revisi membuat setiap item `done`
+  // otomatis tidak memenuhi sampai dibuktikan ulang - tanpa menulis ulang
+  // statusnya, sehingga penggabungan antar-proses tidak saling menghapus.
+  workflowState.state.dodRevision = (Number(workflowState.state.dodRevision) || 0) + 1;
   await workflowState.save();
   return true;
 }

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

@@ -1,10 +1,10 @@
 import { textResponse, formatChecklist, isReleaseSatisfied, getContinueGuidance, resetToCommitIfWorkingChanges } from "./shared.js";
 import { handleCommitAndPush } from "./commit-handlers.js";
+import { openItems, renderChecklist, renderOutstanding, summarize } from "./dod.js";
 
 export async function handleGetWorkflowStatus(workflowState) {
   const status = workflowState.state;
   const nextStep = status ? status.currentPhase : "idle";
-
   // Deteksi berkas state yang terakhir ditulis proses MCP lain. Tanpa
   // peringatan ini, agen bisa meng-commit atas nama task orang lain.
   let sharedWarning = "";
@@ -25,6 +25,15 @@ export async function handleGetWorkflowStatus(workflowState) {
     // Status tetap ditampilkan walau pemeriksaan berkas gagal.
   }
 
+  const dodItems = Array.isArray(status.definitionOfDone) ? status.definitionOfDone : [];
+  const dod = summarize(dodItems, status.dodRevision);
+  const dodSource = status.dodSource === "factory" ? " (dari papan Factory)" : "";
+  const dodBlock =
+    dodItems.length === 0
+      ? "DoD: belum ada item - isi dengan 'set_definition_of_done'"
+      : `DoD: ${dod.done}/${dod.total} selesai, ${dod.waived} dilewati, ${dod.open} terbuka${dodSource}\n` +
+        renderChecklist(dodItems, status.dodRevision);
+
   return textResponse(
     `📊 Current Workflow Status:
 
@@ -39,6 +48,8 @@ Ready check: ${status.readyCheckCompleted ? "✅" : "❌"}
 Commit & push: ${status.commitAndPushCompleted ? "✅" : "❌"}
 Released: ${status.released ? "✅" : "❌"}
 
+${dodBlock}
+
 Next step: ${nextStep}${sharedWarning}`
   );
 }
@@ -47,9 +58,18 @@ export async function handleReadyCheck(workflowState) {
   const status = workflowState.state;
   const testsCreatedDone = status.testsSkipped || status.testsCreated;
   const testsPassedDone = status.testsSkipped || status.testsPassed;
+
+  // Definition of Done adalah prasyarat, bukan langkah baru: ia tidak pernah
+  // memindahkan `currentPhase` sendiri. Ia hanya memutuskan lolos atau tidak.
+  const dodItems = Array.isArray(status.definitionOfDone) ? status.definitionOfDone : [];
+  const dod = summarize(dodItems, status.dodRevision);
+  const dodRecorded = dodItems.length > 0;
+  const dodSatisfied = dodRecorded && dod.open === 0;
+
   const checks = [
     { name: "Task started", done: status.currentPhase !== "idle" },
     { name: "Feature flow described", done: status.featureFlowCreated },
+    { name: "Definition of done recorded", done: dodRecorded },
     { name: "Feature/bug fixed", done: status.bugFixed },
     {
       name: status.testsSkipped ? "Tests skipped (manual QA documented)" : "Tests created",
@@ -60,6 +80,7 @@ export async function handleReadyCheck(workflowState) {
       done: testsPassedDone,
     },
     { name: "Documentation created", done: status.documentationCreated },
+    { name: "Definition of done satisfied", done: dodSatisfied },
   ];
 
   const allDone = checks.every((c) => c.done);
@@ -81,7 +102,24 @@ export async function handleReadyCheck(workflowState) {
     );
   }
 
-  return textResponse(`⚠️ NOT READY TO COMMIT!\n\n${checkList}\n\nPlease complete all steps before committing.`);
+  // Sebut item yang menghalangi, bukan hanya centang merah: agen yang ditolak
+  // harus tahu persis apa yang harus dibuktikan atau dikecualikan.
+  const hints = [];
+  if (!dodRecorded) {
+    hints.push(
+      "Belum ada item DoD untuk task ini. Isi dengan 'set_definition_of_done' { items: [...] } " +
+        "sebelum task bisa di-commit."
+    );
+  } else if (!dodSatisfied) {
+    hints.push(
+      `Item DoD yang belum terpenuhi:\n${renderOutstanding(dodItems, status.dodRevision)}\n` +
+        `Buktikan dengan 'mark_dod_item' { id, evidence } atau kecualikan dengan 'waive_dod_item' { id, reason }.`
+    );
+  }
+
+  const hintBlock = hints.length > 0 ? `\n\n${hints.join("\n\n")}` : "";
+
+  return textResponse(`⚠️ NOT READY TO COMMIT!\n\n${checkList}${hintBlock}\n\nPlease complete all steps before committing.`);
 }
 
 export async function handleContinueWorkflow(workflowState, context) {
@@ -138,6 +176,17 @@ export async function handleContinueWorkflow(workflowState, context) {
 export async function handleRerunWorkflow(workflowState) {
   const currentDescription = workflowState.state.taskDescription;
   const currentType = workflowState.state.taskType;
+  // DoD ikut melewati reset. Tanpa ini, `rerun_workflow` menghapus checklist
+  // dan meninggalkan task yang tidak akan pernah bisa ditutup, karena gerbang
+  // menolak task tanpa item DoD.
+  const dod = {
+    definitionOfDone: Array.isArray(workflowState.state.definitionOfDone)
+      ? workflowState.state.definitionOfDone.map((item) => ({ ...item }))
+      : [],
+    dodSource: workflowState.state.dodSource || "",
+    dodFactoryTaskId: workflowState.state.dodFactoryTaskId || "",
+    dodRevision: Number(workflowState.state.dodRevision) || 0,
+  };
 
   if (!currentDescription) {
     return textResponse("⚠️ No active task to rerun. Use 'start_task' to begin a new workflow.");
@@ -148,9 +197,18 @@ export async function handleRerunWorkflow(workflowState) {
   workflowState.state.currentPhase = "coding";
   workflowState.state.taskDescription = currentDescription;
   workflowState.state.taskType = currentType;
+  Object.assign(workflowState.state, dod);
   await workflowState.save();
 
+  const dodNote =
+    dod.definitionOfDone.length > 0
+      ? `\n\nDoD dipertahankan: ${dod.definitionOfDone.length} item` +
+        ` (${dod.definitionOfDone.filter((item) => item.status === "done").length} sudah terbukti).` +
+        `\nItem yang sudah terbukti TIDAK perlu dibuktikan ulang - kecualikan dengan 'waive_dod_item',` +
+        ` atau tambah item baru dengan 'set_definition_of_done' { items: [...], append: true }.`
+      : "";
+
   return textResponse(
-    `🔄 Rerunning workflow from the start!\n\nTask: ${currentDescription}\nType: ${currentType}\n\nWorkflow Steps:\n1. ✓ Start task (current)\n2. ⏳ Describe feature flow with Mermaid\n3. ⏳ Fix/implement the feature\n4. ⏳ Create tests\n5. ⏳ Run tests (must pass!)\n6. ⏳ Create documentation\n7. ⏳ Run 'check_ready_to_commit'\n8. ⏳ Run 'commit_and_push' (commits and pushes)\n9. ⏳ Run 'perform_release' (handles versioning and tags)\n10. ⏳ Complete task\n\n🎯 Be conscious about what you're coding!`
+    `🔄 Rerunning workflow from the start!\n\nTask: ${currentDescription}\nType: ${currentType}${dodNote}\n\nWorkflow Steps:\n1. ✓ Start task (current)\n2. ⏳ Describe feature flow with Mermaid\n3. ⏳ Fix/implement the feature\n4. ⏳ Prove each definition-of-done item\n5. ⏳ Create tests\n6. ⏳ Run tests (must pass!)\n7. ⏳ Create documentation\n8. ⏳ Run 'check_ready_to_commit'\n9. ⏳ Run 'commit_and_push' (commits and pushes)\n10. ⏳ Run 'perform_release' (handles versioning and tags)\n11. ⏳ Complete task\n\n🎯 Be conscious about what you're coding!`
   );
 }

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

@@ -1,5 +1,6 @@
 import { classify } from '../../security/policy.js';
 import { textResponse, isReleaseSatisfied, isErrorResponse, ensurePrdExists } from "./shared.js";
+import { validateItemTexts } from "./dod.js";
 import { resolveProjectDir, setActiveProjectDir } from "../../exec.js";
 
 /**
@@ -68,6 +69,19 @@ function pinProjectDir(args, workflowState) {
 }
 
 export async function handleStartTask(args, workflowState) {
+  // 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.
+  const dodCheck = validateItemTexts(args.definitionOfDone);
+  if (!dodCheck.ok) {
+    return textResponse(
+      `⚠️ ${dodCheck.error}\n\n` +
+        `Contoh pemakaian:\n` +
+        `  definitionOfDone: ["build lulus", "halaman login terverifikasi"]\n\n` +
+        `Task BELUM dimulai; workflow sebelumnya tidak diubah.`
+    );
+  }
+
   // Selamatkan dulu pekerjaan yang mungkin tertimpa. Ini menangani dua kasus:
   //   1. Proses MCP LAIN menulis berkas state setelah kita memuatnya.
   //   2. Task kita sendiri yang belum selesai lalu diganti task baru.
@@ -78,6 +92,18 @@ export async function handleStartTask(args, workflowState) {
   workflowState.state.classification = classify(args);
   workflowState.state.taskDescription = args.description;
   workflowState.state.taskType = args.type;
+  workflowState.state.definitionOfDone = dodCheck.items.map((text, index) => ({
+    id: `dod-${index + 1}`,
+    text,
+    status: "open",
+    evidence: "",
+    waivedReason: "",
+    revision: 0,
+    updatedAt: new Date().toISOString(),
+  }));
+  workflowState.state.dodSource = "manual";
+  workflowState.state.dodFactoryTaskId = "";
+  workflowState.state.dodRevision = 0;
   workflowState.state.testsSkipped = false;
   workflowState.state.testsSkippedReason = "";
   workflowState.state.commitAndPushCompleted = false;
@@ -114,8 +140,16 @@ export async function handleStartTask(args, workflowState) {
 
   const warningBlock = warnings.length > 0 ? `\n\n${warnings.join("\n\n")}` : "";
 
+  const dodLines = workflowState.state.definitionOfDone
+    .map((item) => `   ${item.id}: ${item.text}`)
+    .join("\n");
+
   return textResponse(
-    `✅ Task Started: ${args.description}\n\n${project.message}${warningBlock}\n\n🎯 Be conscious about what you're coding!\n\nWorkflow Steps:\n1. ✓ Start task (current)\n2. ⏳ Describe feature flow with Mermaid\n3. ⏳ Fix/implement the feature\n4. ⏳ Create tests\n5. ⏳ Run tests (must pass!)\n6. ⏳ Create documentation\n7. ⏳ Run 'check_ready_to_commit'\n8. ⏳ Run 'commit_and_push' (commits and pushes)\n9. ⏳ Run 'perform_release' (handles versioning and tags) or 'skip_release' (when no release is needed)\n10. ⏳ Complete task\n\nReminder: Focus on writing clean, maintainable code!`
+    `✅ Task Started: ${args.description}\n\n${project.message}${warningBlock}\n\n` +
+      `📋 Definition of Done (${workflowState.state.definitionOfDone.length} item, semua masih terbuka):\n${dodLines}\n` +
+      `   Buktikan tiap item dengan 'mark_dod_item' { id, evidence } setelah benar-benar terbukti,\n` +
+      `   atau kecualikan dengan 'waive_dod_item' { id, reason } bila memang tidak relevan.\n\n` +
+      `🎯 Be conscious about what you're coding!\n\nWorkflow Steps:\n1. ✓ Start task (current)\n2. ⏳ Describe feature flow with Mermaid\n3. ⏳ Fix/implement the feature\n4. ⏳ Prove each definition-of-done item\n5. ⏳ Create tests\n6. ⏳ Run tests (must pass!)\n7. ⏳ Create documentation\n8. ⏳ Run 'check_ready_to_commit'\n9. ⏳ Run 'commit_and_push' (commits and pushes)\n10. ⏳ Run 'perform_release' or 'skip_release' (when no release is needed)\n11. ⏳ Complete task\n12. ✓ Workflow closed\n\nReminder: Focus on writing clean, maintainable code!`
   );
 }