@programinglive/dev-workflow-mcp-server 1.13.16 → 1.14.1

package/AGENTS.md

@@ -7,16 +7,28 @@ You are connected to the `dev-workflow` MCP server. **You MUST NOT perform any c
 ### The Rule of Operation
 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 and type (`feature`, `bugfix`, `refactor`, or `other`).
+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.
 2. **Implement**: Write your code changes.
 3. **Mark Fixed**: Call `mark_bug_fixed` with a summary of the implementation.
-4. **Create Tests**: Create appropriate unit/integration tests covering your changes.
-5. **Run Tests**: Execute your test suite and call `run_tests` with `passed: true` and the test command. **Never commit if tests fail!**
-6. **Document**: Update documentation (README, PRD, release notes) and call `create_documentation`.
-7. **Ready Check**: Call `check_ready_to_commit` to verify all steps.
-8. **Commit & Push**: Call `commit_and_push` with a conventional commit message.
-9. **Release**: Call `perform_release` with the release command (or `skip_release` if non-Node/docs-only).
-10. **Complete**: Call `complete_task` to finish the session and reset the workflow.
+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.
+5. **Create Tests**: Create appropriate unit/integration tests covering your changes.
+6. **Run Tests**: Execute your test suite and call `run_tests` with `passed: true` and the test command. **Never commit if tests fail!**
+7. **Document**: Update documentation (README, PRD, release notes) and call `create_documentation`.
+8. **Ready Check**: Call `check_ready_to_commit` to verify all steps. It fails while any definition-of-done item is still open.
+9. **Commit & Push**: Call `commit_and_push` with a conventional commit message. It refuses while any item is open.
+10. **Release**: Call `perform_release` with the release command (or `skip_release` if non-Node/docs-only).
+11. **Complete**: Call `complete_task` to finish the session and reset the workflow. It refuses while any item is open, and records `dodSummary` in history.
+
+### Definition of Done
+
+`start_task` **requires** `definitionOfDone`: 1-20 items, each 3-300 characters, no duplicates. The workflow will not let you commit or close a task while an item is still open.
+
+- `mark_dod_item { id, evidence }` proves an item. Re-marking a proven item refreshes its evidence.
+- `waive_dod_item { id, reason }` excludes an item with a written reason. A proven item cannot be waived.
+- `set_definition_of_done { items, append }` fills the checklist of a task started before this rule existed. Replacing a list that already has proven items is refused unless `append: true`.
+- When new working changes appear after a commit, `dodRevision` goes up and previously proven items must be re-confirmed against the code that is actually being committed. Waivers survive.
+
+`force_complete_task` remains the audited escape hatch: it records `forced: true` with your reason and the DoD summary.
 
 ### Quick Shortcuts
 - If you have all information ready, you can use `run_full_workflow` to execute all steps safely in sequence.

package/README.md

@@ -110,11 +110,14 @@ See [MCP client configuration](#mcp-client-configuration).
 
 ## Available Tools
 
-22 tools.
+25 tools.
 
 | Tool | Purpose |
 |---|---|
-| `start_task` | Begin a task (always the first step) |
+| `start_task` | Begin a task (always the first step); requires `definitionOfDone` |
+| `set_definition_of_done` | Add or replace the checklist of the current task |
+| `mark_dod_item` | Prove one item, with evidence |
+| `waive_dod_item` | Exclude one item, with a reason |
 | `create_feature_flow` | Record the feature flow as Mermaid |
 | `mark_bug_fixed` | Mark the implementation done |
 | `create_tests` | Mark tests as written |
@@ -142,6 +145,33 @@ See [MCP client configuration](#mcp-client-configuration).
 | `claim_factory_task` | Claim a Factory task and start a local workflow |
 | `sync_task_status` | Report a status change back to Factory |
 
+### Definition of Done
+
+Every task carries a checklist of the concrete conditions that must be true before it counts as finished. `start_task` requires it:
+
+```json
+{
+  "description": "Perbaiki validasi form appointment",
+  "type": "bugfix",
+  "projectDir": "D:\\code\\clinic",
+  "definitionOfDone": ["build lulus", "validasi menolak input kosong"]
+}
+```
+
+Each item is later either **proven** or **excluded**, and the workflow refuses to commit or close the task while any item is still open:
+
+```json
+{ "id": "dod-1", "evidence": "php artisan test -> 412 pass" }
+{ "id": "dod-2", "reason": "form ini tidak punya jalur input kosong, sudah dicek di controller" }
+```
+
+- Evidence is required (5-500 characters). It is what separates "proven" from "claimed".
+- An excluded item keeps its reason in the state and in the `history` entry's `definitionOfDoneSummary`.
+- When new working changes appear after a commit, `dodRevision` increments and previously proven items must be re-confirmed against the code that is actually being committed. Waivers survive.
+- A task claimed from the Factory board imports the board checklist as **open** items: a checked box on the board is someone's plan, not proof that this machine ran anything.
+- `set_definition_of_done` fills the checklist of a task started before this rule existed. Replacing a list that already has proven items is refused unless `append: true`.
+- `force_complete_task` is the audited escape hatch: `forced: true`, your reason, and the DoD summary land in history.
+
 ### Factory task integration
 
 Five tools connect this server to the **Factory** board at
@@ -617,7 +647,12 @@ Since 30 October 2026 the reliable fix is **per task**, not global. Pass
 git operation uses it:
 
 ```json
-{ "description": "Fix login redirect", "type": "bugfix", "projectDir": "D:\\code\\clinic" }
+{
+  "description": "Fix login redirect",
+  "type": "bugfix",
+  "projectDir": "D:\\code\\clinic",
+  "definitionOfDone": ["redirect kembali ke halaman asal", "build lulus"]
+}
 ```
 
 `start_task` answers with `📁 Repo proyek: <path> (<source>)`, so the repo in use

package/netlify.toml

@@ -1,7 +1,24 @@
+# Deploy for devworkflow.programinglive.com
+#
+# The site is a Next.js **static export** (`output: "export"` in
+# web/next.config.ts), so `next build` writes plain HTML/JS into `web/out` and
+# there is no server runtime at all.
+#
+# Two things this file has to get right, because both have silently broken the
+# deploy before:
+#
+#   1. `publish` must point at `out`, relative to `base`. With the line removed
+#      ("auto-detection"), Netlify could not find the export and kept serving an
+#      old successful deploy while every new build looked fine.
+#   2. `@netlify/plugin-nextjs` must NOT be loaded. It is for server-rendered
+#      Next.js and expects `.next`; with a static export it only adds ways for
+#      the build to fail.
 [build]
   base = "web"
   command = "npm run build"
-  # publish = ".next" (Removed to allow auto-detection)
+  publish = "out"
 
-[[plugins]]
-  package = "@netlify/plugin-nextjs"
+[build.environment]
+  # Next.js 16 requires Node 20.9+. Pin it so a Netlify default bump cannot
+  # change the build under us.
+  NODE_VERSION = "22"

package/package.json

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

package/tools/definitions.js

@@ -33,8 +33,87 @@ export function getToolList() {
               "Pass it whenever the session directory is not itself a git repository, " +
               "otherwise the server may fall back to WORKFLOW_PROJECT_DIR and commit to the wrong repo.",
           },
+          definitionOfDone: {
+            type: "array",
+            items: { type: "string" },
+            minItems: 1,
+            maxItems: 20,
+            description:
+              "REQUIRED. The concrete conditions that must be true before this task counts as done, " +
+              "one condition per item, for example ['build lulus', 'halaman login terverifikasi']. " +
+              "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.",
+          },
+        },
+        required: ["description", "type", "definitionOfDone"],
+      },
+    },
+    {
+      name: "set_definition_of_done",
+      description:
+        "Add or replace the definition-of-done checklist of the CURRENT task. Use it to fill the checklist of a task started before this feature existed, because a task cannot be committed or closed while any item is open. Replacing a list that already contains proven or waived items is refused unless 'append' is true. Items that are not proven must be waived with a written reason instead of quietly dropped.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          items: {
+            type: "array",
+            items: { type: "string" },
+            minItems: 1,
+            maxItems: 20,
+            description:
+              "Conditions that must be true before the task is done, 3-300 characters each, for example ['build lulus', 'halaman login terverifikasi'].",
+          },
+          append: {
+            type: "boolean",
+            description:
+              "When true, add the items to the existing checklist instead of replacing it. Required when the current checklist already has proven or waived items.",
+          },
+          reason: {
+            type: "string",
+            description: "Optional note recorded with the change.",
+          },
+        },
+        required: ["items"],
+      },
+    },
+    {
+      name: "mark_dod_item",
+      description:
+        "Mark one definition-of-done item as proven, with the evidence that proves it. Evidence is required: 5-500 characters naming what was actually run or checked, for example 'npm test -> 482 pass'. Marking an already-proven item again is allowed and refreshes its evidence, which is how a stale item is re-confirmed after new changes. Waived items cannot be marked; reinstate them with set_definition_of_done { append: true }.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          id: {
+            type: "string",
+            description: "Item id from start_task, get_workflow_status, or set_definition_of_done (for example 'dod-2').",
+          },
+          evidence: {
+            type: "string",
+            description:
+              "What proves the condition is true, 5-500 characters. Name the command and its result, or the page and what you saw.",
+          },
+        },
+        required: ["id", "evidence"],
+      },
+    },
+    {
+      name: "waive_dod_item",
+      description:
+        "Exclude one definition-of-done item with a written reason, for work that turned out not to be needed for this task. The reason is required (5-500 characters) and is recorded in the state and in the history entry, so it must be readable by someone else. A proven item cannot be waived.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          id: {
+            type: "string",
+            description: "Item id from start_task or get_workflow_status (for example 'dod-3').",
+          },
+          reason: {
+            type: "string",
+            description:
+              "Why this condition does not apply to this task, 5-500 characters. Do not use it to avoid work that is actually required.",
+          },
         },
-        required: ["description", "type"],
+        required: ["id", "reason"],
       },
     },
     {

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

@@ -1,5 +1,6 @@
 import { textResponse, isReleaseSatisfied, formatChecklist } from "./shared.js";
 import { handleReadyCheck } from "./status-handlers.js";
+import { openItems, renderChecklist, renderOutstanding, summarize } from "./dod.js";
 import { containsTestFilesInStatus } from "../../git-helpers.js";
 import { resolveProjectDir, setActiveProjectDir, getActiveProjectDir } from "../../exec.js";
 import path from "path";
@@ -122,6 +123,23 @@ export async function handleCommitAndPush(args, context) {
 
   workflowState.state.projectDir = getActiveProjectDir() || workflowState.state.projectDir || "";
 
+  // Guard DoD yang eksplisit. `handleReadyCheck` di bawah sudah menutupi ini
+  // secara transitif, tetapi pesannya generik ("NOT READY"); di sini kita bisa
+  // menyebut item mana yang menghalangi, sebelum satu perintah git pun jalan.
+  const dodItems = Array.isArray(workflowState.state.definitionOfDone)
+    ? workflowState.state.definitionOfDone
+    : [];
+  const outstanding = openItems(dodItems, workflowState.state.dodRevision);
+  if (outstanding.length > 0) {
+    return textResponse(
+      `⚠️ Dibatalkan: ${outstanding.length} item Definition of Done belum terpenuhi.\n\n` +
+        `${renderOutstanding(dodItems, workflowState.state.dodRevision)}\n\n` +
+        `Buktikan dengan 'mark_dod_item' { id, evidence }, atau kecualikan dengan ` +
+        `'waive_dod_item' { id, reason }.\n\n` +
+        `Tidak ada yang di-stage dan tidak ada yang di-commit.`
+    );
+  }
+
   if (!workflowState.state.readyToCommit || !workflowState.state.readyCheckCompleted) {
     const readyResponse = await handleReadyCheck(workflowState);
     if (workflowState.state.currentPhase !== "commit") {
@@ -302,10 +320,35 @@ export async function handleCommitAndPush(args, context) {
 }
 
 export async function handleCompleteTask(args, workflowState) {
+  // Sampai 31 Oktober 2026 fungsi ini tidak memeriksa apa pun: task bisa
+  // ditutup dengan DoD kosong atau masih penuh item terbuka. Sekarang tidak.
+  const dodState = workflowState.state;
+  const dodItems = Array.isArray(dodState.definitionOfDone) ? dodState.definitionOfDone : [];
+  const dod = summarize(dodItems, dodState.dodRevision);
+
+  if (dodItems.length === 0) {
+    return textResponse(
+      `⚠️ Task ini belum punya Definition of Done, jadi belum bisa ditutup.\n\n` +
+        `Isi dulu dengan 'set_definition_of_done' { items: [...] }, buktikan tiap item, lalu ulangi 'complete_task'.\n` +
+        `Kalau memang harus ditutup sekarang, pakai 'force_complete_task' dengan alasan - langkah itu tercatat.`
+    );
+  }
+
+  if (dod.open > 0) {
+    const outstanding = openItems(dodItems, dodState.dodRevision);
+    return textResponse(
+      `⚠️ ${dod.open} item Definition of Done masih terbuka:\n\n` +
+        `${renderOutstanding(dodItems, dodState.dodRevision)}\n\n` +
+        `Buktikan dengan 'mark_dod_item' { id, evidence } atau kecualikan dengan ` +
+        `'waive_dod_item' { id, reason }.`
+    );
+  }
+
   const entry = {
     taskDescription: workflowState.state.taskDescription,
     taskType: workflowState.state.taskType,
     commitMessage: args.commitMessage,
+    definitionOfDoneSummary: dod,
   };
 
   workflowState.addToHistory(entry);
@@ -313,7 +356,8 @@ export async function handleCompleteTask(args, workflowState) {
   await workflowState.save();
 
   return textResponse(
-    `✅ Task completed!\n\nCommit message: ${args.commitMessage}\nHistory recorded.`
+    `✅ Task completed!\n\nCommit message: ${args.commitMessage}\n` +
+      `DoD: ${dod.done}/${dod.total} terbukti, ${dod.waived} dikecualikan.\nHistory recorded.`
   );
 }
 
@@ -331,6 +375,10 @@ export async function handleForceCompleteTask(args, workflowState) {
     commitMessage,
     forced: true,
     forceReason: reason,
+    definitionOfDoneSummary: summarize(
+      Array.isArray(workflowState.state.definitionOfDone) ? workflowState.state.definitionOfDone : [],
+      workflowState.state.dodRevision,
+    ),
   });
 
   workflowState.reset();
@@ -350,6 +398,10 @@ export async function handleDropTask(args, workflowState) {
     commitMessage: workflowState.state.lastCommitMessage,
     dropped: true,
     dropReason: typeof args.reason === "string" ? args.reason : "",
+    definitionOfDoneSummary: summarize(
+      Array.isArray(workflowState.state.definitionOfDone) ? workflowState.state.definitionOfDone : [],
+      workflowState.state.dodRevision,
+    ),
   });
   workflowState.reset();
   await workflowState.save();

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

@@ -0,0 +1,217 @@
+/**
+ * Handler untuk Definition of Done.
+ *
+ * Tipis dengan sengaja: aturan "apa yang sah" hidup di `dod.js`, dan handler di
+ * sini hanya memvalidasi, mengubah state, lalu menyimpan. Kalau logika aturan
+ * ikut masuk ke sini, ia hanya bisa diuji lewat MCP penuh.
+ */
+import { textResponse } from "./shared.js";
+import {
+  MAX_ITEMS,
+  MAX_EVIDENCE,
+  MIN_EVIDENCE,
+  validateItemTexts,
+  nextItemId,
+  renderChecklist,
+} from "./dod.js";
+
+function noActiveTask() {
+  return textResponse("⚠️ No active task. Use 'start_task' first, or 'set_definition_of_done' after starting one.");
+}
+
+function findItem(state, id) {
+  const items = Array.isArray(state.definitionOfDone) ? state.definitionOfDone : [];
+  return items.find((item) => item.id === id) || null;
+}
+
+function itemList(state) {
+  const items = Array.isArray(state.definitionOfDone) ? state.definitionOfDone : [];
+  return items.map((item) => `   ${item.id} [${item.status}]: ${item.text}`).join("\n");
+}
+
+function touch(workflowState) {
+  workflowState.state.readyCheckCompleted = false;
+  workflowState.state.readyToCommit = false;
+}
+
+function newItem(text, state) {
+  return {
+    id: nextItemId(state.definitionOfDone || []),
+    text,
+    status: "open",
+    evidence: "",
+    waivedReason: "",
+    revision: Number(state.dodRevision) || 0,
+    updatedAt: new Date().toISOString(),
+  };
+}
+
+export async function handleSetDefinitionOfDone(args, workflowState) {
+  const state = workflowState.state;
+  if (!state || state.currentPhase === "idle") {
+    return noActiveTask();
+  }
+
+  const check = validateItemTexts(args.items);
+  if (!check.ok) {
+    return textResponse(
+      `⚠️ ${check.error}\n\n` +
+        `Contoh:\n  items: ["build lulus", "halaman login terverifikasi"]`,
+    );
+  }
+
+  const existing = Array.isArray(state.definitionOfDone) ? state.definitionOfDone : [];
+  const append = args.append === true;
+
+  // Mengganti seluruh daftar saat sudah ada bukti berarti membuang bukti yang
+  // mungkin sudah diperiksa manusia. Itu tidak boleh terjadi diam-diam.
+  if (!append) {
+    const proven = existing.filter((item) => item.status === "done" || item.status === "waived");
+    if (proven.length > 0) {
+      return textResponse(
+        `⚠️ Daftar ini sudah punya ${proven.length} item yang terbukti atau dikecualikan:\n${itemList(state)}\n\n` +
+          `Mengganti seluruh daftar akan membuang bukti itu. Pilih salah satu:\n` +
+          `  - tambahkan item baru: set_definition_of_done { items: [...], append: true }\n` +
+          `  - mulai ulang workflow: rerun_workflow`,
+      );
+    }
+  }
+
+  const total = (append ? existing.length : 0) + check.items.length;
+  if (total > MAX_ITEMS) {
+    return textResponse(
+      `⚠️ Total item DoD akan menjadi ${total}, melebihi batas ${MAX_ITEMS}. ` +
+        `Ringkas kondisi yang sejenis sebelum menambah.`,
+    );
+  }
+
+  // Duplikat terhadap item yang SUDAH ada juga harus ditolak: dua item dengan
+  // teks sama hanya membuat gerbang bertanya dua kali.
+  const seen = new Set((append ? existing : []).map((item) => item.text.toLowerCase()));
+  for (const text of check.items) {
+    if (seen.has(text.toLowerCase())) {
+      return textResponse(
+        `⚠️ Item "${text}" sudah ada di daftar DoD task ini. Hapus duplikatnya dari permintaan.`,
+      );
+    }
+    seen.add(text.toLowerCase());
+  }
+
+  const items = append ? existing.slice() : [];
+  for (const text of check.items) {
+    items.push(newItem(text, { ...state, definitionOfDone: items }));
+  }
+
+  state.definitionOfDone = items;
+  if (state.dodSource !== "factory") {
+    state.dodSource = "manual";
+  }
+  touch(workflowState);
+  await workflowState.save();
+
+  return textResponse(
+    `✅ Definition of Done ${append ? "ditambah" : "disusun"}: ${items.length} item.\n\n` +
+      renderChecklist(items, state.dodRevision) +
+      `\n\nBuktikan dengan 'mark_dod_item' { id, evidence } atau kecualikan dengan 'waive_dod_item' { id, reason }.`,
+  );
+}
+
+export async function handleMarkDodItem(args, workflowState) {
+  const state = workflowState.state;
+  if (!state || state.currentPhase === "idle") {
+    return noActiveTask();
+  }
+
+  const id = typeof args.id === "string" ? args.id.trim() : "";
+  if (!id) {
+    return textResponse(`⚠️ Sebutkan 'id' item DoD. Yang tersedia:\n${itemList(state)}`);
+  }
+
+  const item = findItem(state, id);
+  if (!item) {
+    return textResponse(`⚠️ Tidak ada item DoD dengan id "${id}". Yang tersedia:\n${itemList(state)}`);
+  }
+
+  if (item.status === "waived") {
+    return textResponse(
+      `⚠️ Item "${item.text}" sudah dikecualikan (${item.waivedReason}).\n` +
+        `Kalau sekarang benar-benar perlu dibuktikan, tambahkan sebagai item baru dengan ` +
+        `set_definition_of_done { items: [...], append: true }.`,
+    );
+  }
+
+  const evidence = typeof args.evidence === "string" ? args.evidence.trim() : "";
+  if (evidence.length < MIN_EVIDENCE || evidence.length > MAX_EVIDENCE) {
+    return textResponse(
+      `⚠️ 'evidence' untuk "${item.text}" harus ${MIN_EVIDENCE}-${MAX_EVIDENCE} karakter dan menyebut buktinya, ` +
+        `contoh: "npm test → 482 pass".\n` +
+        `Bukti adalah yang membuat item ini berbeda dari sekadar klaim.`,
+    );
+  }
+
+  item.status = "done";
+  item.evidence = evidence;
+  item.waivedReason = "";
+  item.revision = Number(state.dodRevision) || 0;
+  item.updatedAt = new Date().toISOString();
+
+  touch(workflowState);
+  await workflowState.save();
+
+  const remaining = state.definitionOfDone.filter((candidate) => candidate.status === "open");
+
+  return textResponse(
+    `✅ Item "${item.text}" terbukti: ${evidence}\n\n` +
+      renderChecklist(state.definitionOfDone, state.dodRevision) +
+      (remaining.length === 0
+        ? `\n\nSemua item DoD sudah terpenuhi.`
+        : `\n\nMasih ${remaining.length} item terbuka: ${remaining.map((candidate) => candidate.id).join(", ")}.`),
+  );
+}
+
+export async function handleWaiveDodItem(args, workflowState) {
+  const state = workflowState.state;
+  if (!state || state.currentPhase === "idle") {
+    return noActiveTask();
+  }
+
+  const id = typeof args.id === "string" ? args.id.trim() : "";
+  if (!id) {
+    return textResponse(`⚠️ Sebutkan 'id' item DoD. Yang tersedia:\n${itemList(state)}`);
+  }
+
+  const item = findItem(state, id);
+  if (!item) {
+    return textResponse(`⚠️ Tidak ada item DoD dengan id "${id}". Yang tersedia:\n${itemList(state)}`);
+  }
+
+  if (item.status === "done") {
+    return textResponse(
+      `⚠️ Item "${item.text}" sudah terbukti (${item.evidence}); tidak ada yang perlu dikecualikan.`,
+    );
+  }
+
+  const reason = typeof args.reason === "string" ? args.reason.trim() : "";
+  if (reason.length < MIN_EVIDENCE || reason.length > MAX_EVIDENCE) {
+    return textResponse(
+      `⚠️ 'reason' untuk "${item.text}" harus ${MIN_EVIDENCE}-${MAX_EVIDENCE} karakter dan menjelaskan ` +
+        `mengapa kondisi ini tidak berlaku untuk task ini.\n` +
+        `Alasan ini dicatat di state dan di history, jadi tulis yang bisa dibaca orang lain.`,
+    );
+  }
+
+  item.status = "waived";
+  item.waivedReason = reason;
+  item.evidence = "";
+  item.revision = Number(state.dodRevision) || 0;
+  item.updatedAt = new Date().toISOString();
+
+  touch(workflowState);
+  await workflowState.save();
+
+  return textResponse(
+    `⚠️ Item "${item.text}" dikecualikan: ${reason}\n\n` +
+      renderChecklist(state.definitionOfDone, state.dodRevision) +
+      `\n\nPengecualian tercatat dan akan muncul di history saat task ditutup.`,
+  );
+}

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!`
   );
 }
 

package/workflow-state.js

@@ -4,6 +4,7 @@ import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync } from
 import path from "path";
 import { assertSafeKnowledge } from './security/policy.js';
 import { sanitize } from './security/sanitizer.js';
+import { normalizeItems as normalizeDodItems, mergeDefinitionOfDone as mergeDodItems } from './tools/handler-modules/dod.js';
 import { fileURLToPath } from "url";
 
 const __filename = fileURLToPath(import.meta.url);
@@ -658,6 +659,14 @@ export class WorkflowState {
       projectDir: "",
       featureFlowCreated: false,
       featureFlowDescription: "",
+      // Definition of Done milik task ini. Aturan dan bentuk itemnya ada di
+      // tools/handler-modules/dod.js; di sini hanya disimpan.
+      definitionOfDone: [],
+      dodSource: "",
+      dodFactoryTaskId: "",
+      // Naik setiap ada perubahan kerja baru setelah commit tercatat, sehingga
+      // bukti item `done` yang lama otomatis tidak lagi berlaku.
+      dodRevision: 0,
       history: [],
       taskType: "",
     };
@@ -702,6 +711,14 @@ export class WorkflowState {
       projectDir: "",
       featureFlowCreated: false,
       featureFlowDescription: "",
+      // Definition of Done milik task ini. Aturan dan bentuk itemnya ada di
+      // tools/handler-modules/dod.js; di sini hanya disimpan.
+      definitionOfDone: [],
+      dodSource: "",
+      dodFactoryTaskId: "",
+      // Naik setiap ada perubahan kerja baru setelah commit tercatat, sehingga
+      // bukti item `done` yang lama otomatis tidak lagi berlaku.
+      dodRevision: 0,
       history: [],
       taskType: "",
     };
@@ -768,6 +785,21 @@ export class WorkflowState {
       if (typeof this.state.featureFlowDescription !== "string") {
         this.state.featureFlowDescription = "";
       }
+      // Berkas state yang ditulis sebelum fitur DoD ada tidak punya field ini.
+      // Ia harus muncul sebagai "belum punya DoD", bukan undefined yang membuat
+      // gerbang melempar TypeError.
+      this.state.definitionOfDone = normalizeDodItems(this.state.definitionOfDone);
+      if (typeof this.state.dodSource !== "string") {
+        this.state.dodSource = "";
+      }
+      if (typeof this.state.dodFactoryTaskId !== "string") {
+        this.state.dodFactoryTaskId = "";
+      }
+      if (!Number.isFinite(Number(this.state.dodRevision)) || Number(this.state.dodRevision) < 0) {
+        this.state.dodRevision = 0;
+      } else {
+        this.state.dodRevision = Math.trunc(Number(this.state.dodRevision));
+      }
     } catch (error) {
       if (error?.code !== "ENOENT") {
         throw error;
@@ -887,6 +919,48 @@ export class WorkflowState {
     }
   }
 
+  /**
+   * Gabungkan item DoD dengan milik disk bila task-nya sama.
+   *
+   * Sama seperti `mergeMonotonicProgress`, ini hanya berlaku untuk task yang
+   * SAMA. `start_task` mengganti task, dan pada saat itu DoD memang harus mulai
+   * dari nol - bukan mewarisi bukti task sebelumnya.
+   *
+   * Bedanya, DoD digabung per item dengan aturan "yang lebih kuat menang",
+   * bukan OR boolean: dua proses MCP bisa melayani task yang sama, dan proses
+   * yang memegang state basi tidak boleh menghapus bukti item yang baru dicatat
+   * proses lain.
+   */
+  mergeDefinitionOfDone(reconciled) {
+    const diskTask = (reconciled?.diskTask || "").trim();
+    const ourTask = (this.state.taskDescription || "").trim();
+    if (!diskTask || !ourTask || diskTask !== ourTask) {
+      return 0;
+    }
+    if ((reconciled?.diskPhase || "idle") === "idle") {
+      return 0;
+    }
+
+    const disk = reconciled?.diskState;
+    if (!disk) {
+      return 0;
+    }
+
+    const before = Array.isArray(this.state.definitionOfDone) ? this.state.definitionOfDone : [];
+    const merged = mergeDodItems(before, normalizeDodItems(disk.definitionOfDone));
+    this.state.definitionOfDone = merged;
+
+    // Revisi hanya boleh maju: revisi yang lebih tinggi berarti ada perubahan
+    // kerja baru yang sudah diketahui proses lain. Mundur berarti bukti basi
+    // diam-diam dihidupkan kembali.
+    const diskRevision = Number(disk.dodRevision);
+    if (Number.isFinite(diskRevision) && diskRevision > Number(this.state.dodRevision || 0)) {
+      this.state.dodRevision = Math.trunc(diskRevision);
+    }
+
+    return merged.length - before.length;
+  }
+
   async save(options = {}) {
     assertSafeKnowledge(this.state);
     const reconciled = await this.reconcileWithDisk();
@@ -918,6 +992,7 @@ export class WorkflowState {
     // disk memang task yang sama. `start_task` mengganti task, dan pada saat itu
     // flag harus benar-benar direset, bukan dihidupkan kembali.
     this.mergeMonotonicProgress(reconciled);
+    this.mergeDefinitionOfDone(reconciled);
 
     this.state.owner = {
       processMarker: PROCESS_TOKEN,
@@ -1272,6 +1347,14 @@ export class WorkflowState {
       projectDir: "",
       featureFlowCreated: false,
       featureFlowDescription: "",
+      // Definition of Done milik task ini. Aturan dan bentuk itemnya ada di
+      // tools/handler-modules/dod.js; di sini hanya disimpan.
+      definitionOfDone: [],
+      dodSource: "",
+      dodFactoryTaskId: "",
+      // Naik setiap ada perubahan kerja baru setelah commit tercatat, sehingga
+      // bukti item `done` yang lama otomatis tidak lagi berlaku.
+      dodRevision: 0,
       history,
       taskType: "",
     };