@programinglive/dev-workflow-mcp-server 1.13.9 → 1.13.11

package/README.md

@@ -610,14 +610,33 @@ then reinstall.
 changes** - git ran in the wrong repository. The server used to fall back to its
 own package directory, which is also a git repo, so commits landed there (or
 nowhere) instead of in your project. It now refuses to run git in the package
-repo and asks for the project explicitly:
+repo and asks for the project explicitly.
+
+Since 30 October 2026 the reliable fix is **per task**, not global. Pass
+`projectDir` to `start_task`; the repo is pinned for that task and every later
+git operation uses it:
+
+```json
+{ "description": "Fix login redirect", "type": "bugfix", "projectDir": "D:\\code\\clinic" }
+```
+
+`start_task` answers with `📁 Repo proyek: <path> (<source>)`, so the repo in use
+is never a guess. `commit_and_push` repeats it on every response.
+
+`WORKFLOW_PROJECT_DIR` still works as an operator-wide default and still wins
+over the session directory, but it is one value for the whole server process.
+When the session directory points at a *different* repo, `start_task` now
+reports `⚠️ KONFLIK` and tells you to pass `projectDir` — previously that
+mismatch was silent, which is how a commit landed in the wrong repo. Prefer
+`projectDir`; keep the env var only for machines with a single project.
 
 ```bash
 export WORKFLOW_PROJECT_DIR=/path/to/your/project
 ```
 
 Point it at any directory inside the project; the repo root is discovered
-upward. Non-git commands are unaffected.
+upward. Non-git commands are unaffected. Full incident write-up:
+[`docs/2026-10-30-project-dir-misrouting.md`](docs/2026-10-30-project-dir-misrouting.md).
 
 **A task jumped straight to `done` after reporting `review`** - it was reported
 twice. Factory treats the second report as approval. Current versions block that

package/exec.js

@@ -49,64 +49,138 @@ function samePath(a, b) {
 }
 
 /**
- * Menentukan direktori repo proyek tempat git boleh dijalankan.
+ * Direktori repo proyek yang aktif untuk pemanggilan ini.
  *
- * Urutan: eksplisit -> WORKFLOW_PROJECT_DIR/PROJECT_DIR -> kandidat.
+ * Kenapa ada: `WORKFLOW_PROJECT_DIR` adalah satu nilai global untuk seluruh
+ * proses MCP. Di mesin ini nilainya `D:\code\clinic`, sehingga sesi yang
+ * sebenarnya bekerja di repo lain tetap menjalankan git di clinic — dan
+ * `commit_and_push` melaporkan "No changes detected" seolah sudah selesai.
  *
- * Repo paket MCP sengaja tidak dipilih sebagai cadangan: dulu server pernah
- * menjalankan git di repo-nya sendiri saat cwd proyek gagal diresolusi, lalu
- * melaporkan "No changes detected" sementara perubahan proyek tidak pernah
- * ter-commit.
+ * Direktori aktif diisi dari state sesi (`projectDir`), yang ditentukan saat
+ * `start_task` atau saat `commit_and_push`/`perform_release` dipanggil dengan
+ * argumen `projectDir` eksplisit.
+ */
+let activeProjectDir = "";
+
+export function setActiveProjectDir(dir) {
+  activeProjectDir = dir ? path.resolve(dir) : "";
+  return activeProjectDir;
+}
+
+export function getActiveProjectDir() {
+  return activeProjectDir;
+}
+
+function repoRootOrThrow(dir, message) {
+  const root = findRepoRoot(dir);
+  if (!root) {
+    throw new Error(message);
+  }
+  return root;
+}
+
+/**
+ * Menentukan direktori repo proyek, sekaligus melaporkan DARI MANA asalnya.
  *
- * Tetapi kandidat yang MEMANG berada di dalam repo paket berarti pemanggil
- * sengaja bekerja di sana - misalnya saat mengembangkan server MCP ini sendiri.
- * Membuangnya tanpa syarat membuat `commit_and_push` mustahil dipakai di repo
- * paket, jadi kandidat seperti itu diterima. Repo proyek lain tetap menang.
+ * Urutan (per 30 Oktober 2026):
+ *   1. explicit  - argumen `projectDir` pada panggilan tool
+ *   2. pinned    - `projectDir` yang dicatat `start_task` untuk sesi ini
+ *   3. env       - WORKFLOW_PROJECT_DIR / PROJECT_DIR (setelan operator, global)
+ *   4. cwd       - direktori kerja sesi (kandidat)
+ *
+ * `env` tetap di atas `cwd` karena ia setelan operator yang disengaja: kalau
+ * seseorang menunjuk repo lewat env, ia bermaksud demikian.
+ *
+ * Yang berubah: env sekarang bisa DIKALAHKAN per sesi lewat `projectDir`, dan
+ * bila env dipakai sementara direktori sesi menunjuk repo lain, konfliknya
+ * dilaporkan (`conflict`). Sebelumnya tidak ada jalan keluar sama sekali:
+ * satu nilai global membajak semua sesi, `git status` di repo yang salah
+ * menjawab "bersih", dan workflow melaporkan sukses palsu.
+ *
+ * `source` dan `conflict` dipakai tool untuk memberi tahu pengguna repo mana
+ * yang dipakai - dan kapan ia kemungkinan salah.
  */
-export function resolveWorkingDirectory({ explicit = "", env = process.env, candidates = [] } = {}) {
+export function resolveProjectDir({ explicit = "", pinned = "", env = process.env, candidates = [] } = {}) {
   if (explicit) {
-    const root = findRepoRoot(explicit);
-    if (!root) {
-      throw new Error(`Direktori "${explicit}" bukan repo git (tidak ada .git).`);
-    }
-    return root;
+    return {
+      dir: repoRootOrThrow(explicit, `Direktori "${explicit}" bukan repo git (tidak ada .git).`),
+      source: "explicit",
+      conflict: null,
+    };
   }
 
-  const envDir = (env.WORKFLOW_PROJECT_DIR || env.PROJECT_DIR || "").trim();
-  if (envDir) {
-    const root = findRepoRoot(envDir);
-    if (!root) {
-      throw new Error(`WORKFLOW_PROJECT_DIR "${envDir}" bukan repo git (tidak ada .git).`);
-    }
-    return root;
+  if (pinned) {
+    return {
+      dir: repoRootOrThrow(
+        pinned,
+        `projectDir sesi "${pinned}" bukan repo git (tidak ada .git). ` +
+        "Perbaiki dengan memanggil 'start_task' lagi dengan projectDir yang benar.",
+      ),
+      source: "pinned",
+      conflict: null,
+    };
   }
 
   const found = candidates.map((candidate) => findRepoRoot(candidate)).filter(Boolean);
+  const cwdRepo = found.find((dir) => !samePath(dir, PACKAGE_DIR)) || null;
+  const packageCandidate = found.some((dir) => samePath(dir, PACKAGE_DIR));
+
+  const envDir = (env.WORKFLOW_PROJECT_DIR || env.PROJECT_DIR || "").trim();
+  if (envDir) {
+    const envRepo = repoRootOrThrow(envDir, `WORKFLOW_PROJECT_DIR "${envDir}" bukan repo git (tidak ada .git).`);
+    return {
+      dir: envRepo,
+      source: "env",
+      // Direktori sesi menunjuk repo lain: kemungkinan besar env ini milik
+      // proyek lain, dan git akan berjalan di repo yang salah.
+      conflict: cwdRepo && !samePath(cwdRepo, envRepo) ? { envDir: envRepo, cwdDir: cwdRepo } : null,
+    };
+  }
 
-  const projectRepo = found.find((dir) => !samePath(dir, PACKAGE_DIR));
-  if (projectRepo) {
-    return projectRepo;
+  if (cwdRepo) {
+    return { dir: cwdRepo, source: "cwd", conflict: null };
   }
 
   // Hanya repo paket yang ditemukan. Itu hanya mungkin bila salah satu kandidat
   // benar-benar berada di dalamnya, jadi pemanggil memilih repo ini dengan sadar.
-  if (found.some((dir) => samePath(dir, PACKAGE_DIR))) {
-    return path.resolve(PACKAGE_DIR);
+  if (packageCandidate) {
+    return { dir: path.resolve(PACKAGE_DIR), source: "cwd", conflict: null };
   }
 
   throw new Error(
     "Tidak bisa menentukan repo proyek: tidak ada repository git pada " +
     `${candidates.filter(Boolean).map((candidate) => `"${candidate}"`).join(", ") || "direktori kerja"}. ` +
-    "Set WORKFLOW_PROJECT_DIR ke direktori proyek, atau jalankan server MCP dari dalam direktori proyek.",
+    "Sebutkan 'projectDir' pada 'start_task' (disarankan), atau set WORKFLOW_PROJECT_DIR, " +
+    "atau jalankan server MCP dari dalam direktori proyek.",
   );
 }
 
+/**
+ * Penentu direktori repo proyek tempat git boleh dijalankan.
+ *
+ * Urutan: eksplisit -> WORKFLOW_PROJECT_DIR/PROJECT_DIR -> kandidat.
+ *
+ * Repo paket MCP sengaja tidak dipilih sebagai cadangan: dulu server pernah
+ * menjalankan git di repo-nya sendiri saat cwd proyek gagal diresolusi, lalu
+ * melaporkan "No changes detected" sementara perubahan proyek tidak pernah
+ * ter-commit.
+ *
+ * Tetapi kandidat yang MEMANG berada di dalam repo paket berarti pemanggil
+ * sengaja bekerja di sana - misalnya saat mengembangkan server MCP ini sendiri.
+ * Membuangnya tanpa syarat membuat `commit_and_push` mustahil dipakai di repo
+ * paket, jadi kandidat seperti itu diterima. Repo proyek lain tetap menang.
+ */
+export function resolveWorkingDirectory(options = {}) {
+  return resolveProjectDir(options).dir;
+}
+
 function getDefaultCwd(command) {
   try {
-    return resolveWorkingDirectory({
+    return resolveProjectDir({
+      explicit: activeProjectDir,
       env: process.env,
       candidates: [process.cwd(), process.env.INIT_CWD],
-    });
+    }).dir;
   } catch (error) {
     // Perintah non-git (echo, npm run release, ...) tidak butuh repo proyek.
     // Yang berbahaya hanya git: di sana cwd menentukan repo mana yang diubah.

package/git-facade.js

@@ -10,8 +10,10 @@
 
 import {
   getCurrentBranch,
+  getHeadSha,
   getLastCommitMessage,
   getPrimaryBranch,
+  getRemoteBranchSha,
   getStagedChanges,
   getStatusOutput,
   hasStagedChanges,
@@ -27,7 +29,9 @@ export function createGitFacade() {
     hasStagedChanges,
     getStagedChanges,
     getCurrentBranch,
+    getHeadSha,
     getPrimaryBranch,
+    getRemoteBranchSha,
     getLastCommitMessage,
     getStatusOutput,
     workingTreeSummary,

package/git-helpers.js

@@ -145,6 +145,29 @@ export async function getCurrentBranch() {
   return stdout.trim();
 }
 
+/**
+ * SHA commit yang sedang di HEAD.
+ *
+ * Dipakai untuk membuktikan bahwa push benar-benar mengirim commit ini, bukan
+ * hanya "git push" yang keluar 0 tanpa memindahkan apa pun.
+ */
+export async function getHeadSha() {
+  const { stdout } = await exec("git rev-parse HEAD");
+  return stdout.trim();
+}
+
+/**
+ * SHA yang tercatat pada remote-tracking ref `origin/<branch>`.
+ * Melempar bila branch itu belum ada di remote.
+ */
+export async function getRemoteBranchSha(branch) {
+  const { stdout } = await exec("git rev-parse", {
+    executable: "git",
+    arguments: ["rev-parse", `origin/${branch}`],
+  });
+  return stdout.trim();
+}
+
 export async function getStatusOutput() {
   const { stdout } = await exec("git status --porcelain");
   return stdout;

package/index.js

@@ -13,7 +13,7 @@ import {
   GetPromptRequestSchema,
 } from "@modelcontextprotocol/sdk/types.js";
 import { fileURLToPath } from "url";
-import { exec } from "./exec.js";
+import { exec, setActiveProjectDir } from "./exec.js";
 import { normalizeRequestArgs, shellEscape } from "./utils.js";
 import { createGitFacade } from "./git-facade.js";
 import {
@@ -60,6 +60,9 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     const sessionId = sessionKeyFromRequest(request);
     if (sessionId) await workflowState.useSession(sessionId);
     await workflowState.load();
+    // Repo proyek mengikuti sesi, bukan satu nilai global. Tanpa ini, sesi yang
+    // bekerja di repo lain tetap menjalankan git di WORKFLOW_PROJECT_DIR.
+    setActiveProjectDir(workflowState.state.projectDir || "");
   }
   return securityOutputFilter(await handleToolCall({
     request,
@@ -234,6 +237,7 @@ async function cliMain(argv) {
     workflowState = new WorkflowState();
     await workflowState.load();
     await workflowState.ensurePrimaryFile();
+    setActiveProjectDir(workflowState.state.projectDir || "");
 
     const request = {
       params: {

package/package.json

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

package/scripts/verify-push-branch.mjs

@@ -0,0 +1,111 @@
+// Verifikasi end-to-end commit_and_push: harus mem-push branch AKTIF.
+// Memanggil handler asli (bukan mock) terhadap repo sementara + remote bare.
+import { execFileSync } from "node:child_process";
+import { mkdtempSync, writeFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+
+import { handleToolCall } from "../tools/handlers.js";
+import { WorkflowState } from "../workflow-state.js";
+import { shellEscape, normalizeRequestArgs } from "../utils.js";
+import { createCommitMessageParts, determineReleaseTypeFromCommit } from "../commit-helpers.js";
+import { createGitFacade } from "../git-facade.js";
+import { exec } from "../exec.js";
+
+const git = (cwd, ...args) =>
+  execFileSync("git", args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }).trim();
+
+const root = mkdtempSync(path.join(tmpdir(), "push-verify-"));
+const remote = path.join(root, "remote.git");
+const work = path.join(root, "work");
+
+try {
+  git(root, "init", "--bare", "-q", remote);
+  git(root, "clone", "-q", remote, work);
+  git(work, "config", "user.email", "test@example.test");
+  git(work, "config", "user.name", "Test");
+
+  writeFileSync(path.join(work, "base.txt"), "awal\n");
+  git(work, "add", ".");
+  git(work, "commit", "-q", "-m", "chore: initial");
+  git(work, "branch", "-M", "main");
+  git(work, "push", "-q", "origin", "main");
+
+  // Branch fitur dengan commit yang BELUM di-push.
+  git(work, "checkout", "-q", "-b", "feat/verifikasi");
+  writeFileSync(path.join(work, "fitur.txt"), "fitur\n");
+  git(work, "add", ".");
+  git(work, "commit", "-q", "-m", "feat: pekerjaan di branch fitur");
+
+  const headBefore = git(work, "rev-parse", "HEAD");
+  const mainBefore = git(work, "rev-parse", "main");
+
+  // Perubahan yang BELUM di-commit, supaya tool menempuh jalur commit + push
+  // (bukan jalur "no changes detected").
+  writeFileSync(path.join(work, "belum-commit.txt"), "perubahan\n");
+
+  console.log("branch aktif :", git(work, "branch", "--show-current"));
+  console.log("HEAD awal    :", headBefore.slice(0, 8));
+  let remoteFeatBefore = "(belum ada)";
+  try {
+    remoteFeatBefore = git(work, "rev-parse", "--verify", "-q", "origin/feat/verifikasi").slice(0, 8);
+  } catch { /* belum ada */ }
+  console.log("origin/feat  :", remoteFeatBefore);
+
+  const stateFile = path.join(root, "state.json");
+  const workflowState = new WorkflowState(stateFile);
+  await workflowState.load();
+  Object.assign(workflowState.state, {
+    currentPhase: "commit",
+    taskDescription: "verifikasi push branch",
+    taskType: "other",
+    featureFlowCreated: true,
+    bugFixed: true,
+    testsCreated: true,
+    testsPassed: true,
+    testsSkipped: true,
+    documentationCreated: true,
+    readyToCommit: true,
+    readyCheckCompleted: true,
+    commitAndPushCompleted: false,
+    projectDir: work,
+    history: [],
+  });
+  await workflowState.save();
+
+  const response = await handleToolCall({
+    request: {
+      params: {
+        name: "commit_and_push",
+        arguments: { commitMessage: "feat: uji push", projectDir: work },
+      },
+    },
+    normalizeRequestArgs,
+    workflowState,
+    exec,
+    git: createGitFacade(),
+    utils: { shellEscape, determineReleaseTypeFromCommit, createCommitMessageParts },
+  });
+
+  console.log("\n=== output tool ===");
+  console.log(response.content[0].text);
+
+  console.log("\n=== hasil di remote ===");
+  let remoteFeat = "";
+  try {
+    remoteFeat = git(work, "rev-parse", "--verify", "-q", "origin/feat/verifikasi");
+  } catch { /* tidak ada */ }
+  const remoteMain = git(work, "rev-parse", "main");
+  console.log("origin/feat/verifikasi :", remoteFeat ? remoteFeat.slice(0, 8) : "(tidak ada)");
+  console.log("origin/main            :", remoteMain.slice(0, 8));
+
+  const headAfter = git(work, "rev-parse", "HEAD");
+  const okFeat = remoteFeat === headAfter;
+  const okMain = remoteMain === mainBefore;
+  console.log("");
+  console.log(okFeat ? "BENAR: remote menerima commit di branch fitur" : "SALAH: remote/feat tidak menerima HEAD");
+  console.log(okMain ? "BENAR: main tidak tersentuh" : "SALAH: main ikut berubah");
+  process.exitCode = okFeat && okMain ? 0 : 1;
+} finally {
+  rmSync(root, { recursive: true, force: true });
+}

package/tools/definitions.js

@@ -25,6 +25,14 @@ export function getToolList() {
             enum: ["feature", "bugfix", "refactor", "other"],
             description: "Type of task",
           },
+          projectDir: {
+            type: "string",
+            description:
+              "Absolute path to the repository this task works on (e.g. D:\\code\\clinic). " +
+              "Pinned for the whole task; every git operation afterwards runs there. " +
+              "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.",
+          },
         },
         required: ["description", "type"],
       },
@@ -153,6 +161,12 @@ export function getToolList() {
             type: "string",
             description: "Optional branch name to push to (defaults to current branch)",
           },
+          projectDir: {
+            type: "string",
+            description:
+              "Absolute path to the repository to commit in. Overrides the repo pinned by 'start_task' " +
+              "for this call. Use it to fix a misdirected commit without restarting the task.",
+          },
         },
         required: [],
       },
@@ -172,6 +186,11 @@ export function getToolList() {
             type: "string",
             description: "Optional release notes",
           },
+          projectDir: {
+            type: "string",
+            description:
+              "Absolute path to the repository to release. Overrides the repo pinned by 'start_task' for this call.",
+          },
         },
         required: ["command"],
       },

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

@@ -1,9 +1,114 @@
 import { textResponse, isReleaseSatisfied, formatChecklist } from "./shared.js";
 import { handleReadyCheck } from "./status-handlers.js";
 import { containsTestFilesInStatus } from "../../git-helpers.js";
+import { resolveProjectDir, setActiveProjectDir, getActiveProjectDir } from "../../exec.js";
+
+/**
+ * Label repo yang benar-benar dipakai, untuk ditampilkan di setiap jawaban.
+ *
+ * Tanpa ini, "No changes detected" tidak bisa dibedakan antara "sudah commit"
+ * dan "git berjalan di repo yang salah". Itu persis yang menyamarkan commit
+ * salah arah pada 30 Oktober 2026.
+ */
+function repoLabel() {
+  try {
+    const resolved = resolveProjectDir({
+      explicit: getActiveProjectDir(),
+      env: process.env,
+      candidates: [process.cwd(), process.env.INIT_CWD],
+    });
+    const origin = resolved.source === "env" ? " — dari WORKFLOW_PROJECT_DIR (global)" : "";
+    return resolved.dir + origin;
+  } catch {
+    return "(tidak bisa ditentukan)";
+  }
+}
+
+/**
+ * Terapkan `projectDir` dari argumen tool bila ada.
+ * Mengembalikan pesan kesalahan, atau null bila tidak ada masalah.
+ */
+function applyProjectDirOverride(args) {
+  const requested = typeof args.projectDir === "string" ? args.projectDir.trim() : "";
+  if (!requested) {
+    return null;
+  }
+
+  try {
+    const resolved = resolveProjectDir({ explicit: requested });
+    setActiveProjectDir(resolved.dir);
+    return null;
+  } catch (error) {
+    return `❌ projectDir tidak valid: ${error.message}`;
+  }
+}
+
+/**
+ * Branch yang benar-benar dipakai untuk push.
+ *
+ * Urutan: `branch` eksplisit -> branch aktif -> primary branch.
+ *
+ * Sebelum 31 Okt 2026 urutannya primaryBranch lebih dulu, dan `getPrimaryBranch()`
+ * selalu menjawab "main" bila `origin/main` ada - tanpa melihat branch aktif.
+ * Akibatnya di worktree yang sedang di `feat/...`, tool menjalankan
+ * `git push origin main`. Karena `main` lokal sudah sama dengan `origin/main`,
+ * perintah itu keluar 0 tanpa mengirim apa pun, lalu tool melaporkan
+ * "Commit and push completed". Dua commit nyata tidak pernah ter-push.
+ *
+ * HEAD yang detached ("HEAD") bukan branch, jadi tidak bisa dipakai.
+ */
+function pickPushBranch({ requestedBranch, currentBranch, primaryBranch }) {
+  if (requestedBranch) return requestedBranch;
+  if (currentBranch && currentBranch !== "HEAD") return currentBranch;
+  return primaryBranch || currentBranch || "";
+}
+
+/**
+ * Pastikan remote benar-benar menerima HEAD.
+ *
+ * `git push` bisa keluar 0 tanpa memindahkan apa pun - itulah yang menyamarkan
+ * bug di atas. Satu-satunya bukti yang bisa dipercaya adalah membandingkan SHA.
+ */
+async function verifyPushed(git, branch) {
+  let head;
+  try {
+    head = await git.getHeadSha();
+  } catch (error) {
+    return { ok: false, detail: `tidak bisa membaca HEAD: ${error.message}` };
+  }
+
+  let remote;
+  try {
+    remote = await git.getRemoteBranchSha(branch);
+  } catch {
+    return {
+      ok: false,
+      detail: `branch origin/${branch} tidak ditemukan di remote setelah push`,
+    };
+  }
+
+  if (remote !== head) {
+    return {
+      ok: false,
+      detail:
+        `origin/${branch} berada di ${remote.slice(0, 8)}, ` +
+        `sedangkan HEAD di ${head.slice(0, 8)}`,
+    };
+  }
+
+  return { ok: true, head };
+}
 
 export async function handleCommitAndPush(args, context) {
   const { workflowState, exec, git, utils } = context;
+
+  const projectDirError = applyProjectDirOverride(args);
+  if (projectDirError) {
+    return textResponse(projectDirError);
+  }
+
+  workflowState.state.projectDir = getActiveProjectDir() || workflowState.state.projectDir || "";
+
   if (!workflowState.state.readyToCommit || !workflowState.state.readyCheckCompleted) {
     const readyResponse = await handleReadyCheck(workflowState);
     if (workflowState.state.currentPhase !== "commit") {
@@ -29,17 +134,31 @@ export async function handleCommitAndPush(args, context) {
   } catch (error) {
     return textResponse(
       `❌ Tidak bisa memeriksa repository Git, jadi tidak ada yang di-commit.\n\n` +
+      `Repo: ${repoLabel()}\n` +
       `Penyebab: ${error.message}\n\n` +
-      `Set WORKFLOW_PROJECT_DIR ke direktori proyek, atau jalankan server MCP dari dalam direktori proyek.`
+      `Sebutkan 'projectDir' pada 'start_task' atau 'commit_and_push' untuk menunjuk repo yang benar.`
     );
   }
 
-  const branchForPush = requestedBranch || primaryBranch || currentBranch || "";
+  const branchForPush = pickPushBranch({ requestedBranch, currentBranch, primaryBranch });
 
   if (!hasWorkingChanges) {
     const lastCommitMessage = await git.getLastCommitMessage();
     const effectiveCommitMessage = lastCommitMessage || providedCommitMessage;
 
+    // "Tidak ada perubahan" bukan berarti "sudah ter-push". HEAD bisa saja
+    // berupa commit yang belum pernah dikirim. Memeriksanya mencegah tool
+    // menandai selesai padahal remote masih tertinggal.
+    const pushed = await verifyPushed(git, branchForPush);
+    if (!pushed.ok) {
+      return textResponse(
+        `⚠️ Tidak ada perubahan untuk di-commit, tetapi HEAD BELUM ada di remote.\n` +
+        `Repo: ${repoLabel()}\nBranch: ${branchForPush || "(tidak diketahui)"}\n` +
+        `Sebab: ${pushed.detail}\n\n` +
+        `Jalankan 'commit_and_push' lagi dengan 'branch' yang benar, atau push manual.`
+      );
+    }
+
     workflowState.state.commitAndPushCompleted = true;
     workflowState.state.lastCommitMessage = effectiveCommitMessage || "";
     workflowState.state.lastPushBranch = branchForPush;
@@ -47,7 +166,7 @@ export async function handleCommitAndPush(args, context) {
     await workflowState.save();
 
     return textResponse(
-      `ℹ️ No changes detected. Assuming commit and push already completed.\nLast commit: ${effectiveCommitMessage || "(unavailable)"
+      `ℹ️ No changes detected. Assuming commit and push already completed.\nRepo: ${repoLabel()}\nBranch: ${branchForPush} (verified on remote)\nLast commit: ${effectiveCommitMessage || "(unavailable)"
       }\n\nNext: Run 'perform_release' to handle the release and push tags.`
     );
   }
@@ -102,6 +221,20 @@ export async function handleCommitAndPush(args, context) {
     );
   }
 
+  // Exit code 0 dari `git push` BUKAN bukti bahwa commit ini terkirim. Kalau
+  // branch yang dipilih sudah sinkron, git tidak melakukan apa pun dan tetap
+  // keluar 0. Satu-satunya bukti yang bisa dipercaya: SHA HEAD ada di remote.
+  const pushed = await verifyPushed(git, branchForPush);
+  if (!pushed.ok) {
+    return textResponse(
+      `❌ Commit dibuat, tetapi TIDAK ter-push.\n` +
+      `Repo: ${repoLabel()}\nBranch: ${branchForPush || "(tidak diketahui)"}\n` +
+      `Sebab: ${pushed.detail}\n\n` +
+      `Commit lokal: ${generatedSummary}\n\n` +
+      `Jalankan 'commit_and_push' lagi dengan 'branch' yang benar, atau push manual.`
+    );
+  }
+
   workflowState.state.commitAndPushCompleted = true;
   workflowState.state.lastCommitMessage = generatedSummary;
   workflowState.state.lastPushBranch = branchForPush;
@@ -109,8 +242,7 @@ export async function handleCommitAndPush(args, context) {
   await workflowState.save();
 
   return textResponse(
-    `✅ Commit and push completed!\n\nCommit message: ${generatedSummary}\nPushed to: ${branchForPush || "(default upstream)"
-    }\n\nNext: Run 'perform_release' to handle the release and push tags.`
+    `✅ Commit and push completed!\nRepo: ${repoLabel()}\n\nCommit message: ${generatedSummary}\nPushed to: ${branchForPush} (verified at ${pushed.head.slice(0, 8)})\n\nNext: Run 'perform_release' to handle the release and push tags.`
   );
 }
 

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

@@ -1,4 +1,5 @@
 import { textResponse, isReleaseSatisfied, resetToCommitIfWorkingChanges, summarizeHistory } from "./shared.js";
+import { resolveProjectDir, setActiveProjectDir, getActiveProjectDir } from "../../exec.js";
 
 export async function handleSkipRelease(args, workflowState) {
   if (workflowState.state.currentPhase === "idle") {
@@ -50,6 +51,18 @@ export async function handlePerformRelease(args, context) {
     return textResponse("⚠️ Please start a task first using 'start_task'!");
   }
 
+  // Sama seperti commit_and_push: projectDir eksplisit menang atas repo sesi.
+  const requestedProjectDir =
+    typeof args.projectDir === "string" ? args.projectDir.trim() : "";
+  if (requestedProjectDir) {
+    try {
+      setActiveProjectDir(resolveProjectDir({ explicit: requestedProjectDir }).dir);
+    } catch (error) {
+      return textResponse(`❌ projectDir tidak valid: ${error.message}`);
+    }
+    workflowState.state.projectDir = getActiveProjectDir();
+  }
+
   let hasNewChanges;
   try {
     hasNewChanges = await resetToCommitIfWorkingChanges(workflowState, git);
@@ -81,7 +94,7 @@ export async function handlePerformRelease(args, context) {
       return textResponse(
         `❌ Tidak bisa memeriksa repository Git, jadi status rilis tidak dapat diverifikasi.\n\n` +
         `Penyebab: ${error.message}\n\n` +
-        `Set WORKFLOW_PROJECT_DIR ke direktori proyek, atau jalankan server MCP dari dalam direktori proyek.`
+        `Sebutkan 'projectDir' pada 'perform_release' untuk menunjuk repo yang benar.`
       );
     }
 

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

@@ -1,5 +1,71 @@
 import { classify } from '../../security/policy.js';
 import { textResponse, isReleaseSatisfied, isErrorResponse, ensurePrdExists } from "./shared.js";
+import { resolveProjectDir, setActiveProjectDir } from "../../exec.js";
+
+/**
+ * Catat repo proyek untuk sesi ini.
+ *
+ * Tanpa ini, satu-satunya penentu adalah WORKFLOW_PROJECT_DIR yang global.
+ * Di mesin ini nilainya `D:\code\clinic`, jadi task yang sebenarnya bekerja di
+ * repo lain tetap menjalankan git di clinic dan `commit_and_push` menjawab
+ * "No changes detected" seolah sudah selesai (30 Oktober 2026).
+ *
+ * Best-effort: kalau repo belum bisa ditentukan, task tetap boleh mulai, tapi
+ * pengguna diberi tahu supaya tidak terkejut saat commit.
+ */
+function pinProjectDir(args, workflowState) {
+  const requested = typeof args.projectDir === "string" ? args.projectDir.trim() : "";
+
+  let resolved = null;
+  let error = null;
+  try {
+    resolved = resolveProjectDir({
+      explicit: requested,
+      env: process.env,
+      candidates: [process.cwd(), process.env.INIT_CWD],
+    });
+  } catch (resolveError) {
+    error = resolveError;
+  }
+
+  if (!resolved) {
+    workflowState.state.projectDir = "";
+    setActiveProjectDir("");
+    return {
+      message:
+        `⚠️ Repo proyek belum ditentukan: ${error.message}\n` +
+        `   Sebutkan 'projectDir' pada 'start_task' supaya commit tidak salah arah.`,
+    };
+  }
+
+  workflowState.state.projectDir = resolved.dir;
+  setActiveProjectDir(resolved.dir);
+
+  const sourceNote = {
+    explicit: "dari argumen projectDir",
+    cwd: "dari direktori kerja sesi",
+    env: "dari WORKFLOW_PROJECT_DIR (nilai global)",
+    pinned: "dari projectDir sesi",
+  }[resolved.source] || resolved.source;
+
+  let message = `📁 Repo proyek: ${resolved.dir} (${sourceNote})`;
+
+  // Sumber env berarti tidak ada sinyal per-sesi sama sekali. Kalau direktori
+  // sesi ternyata menunjuk repo LAIN, hampir pasti env ini milik proyek lain -
+  // dan itulah yang dulu membuat `git add .` berjalan di repo yang salah.
+  if (resolved.conflict) {
+    message +=
+      `\n   ⚠️ KONFLIK: direktori sesi menunjuk repo lain, ${resolved.conflict.cwdDir}.` +
+      `\n   Repo dipilih dari WORKFLOW_PROJECT_DIR. Kalau task ini untuk repo sesi,` +
+      `\n   ulangi 'start_task' dengan projectDir: "${resolved.conflict.cwdDir}".`;
+  } else if (resolved.source === "env") {
+    message +=
+      `\n   ⚠️ Repo ini berasal dari WORKFLOW_PROJECT_DIR, bukan dari sesi.` +
+      `\n   Kalau task ini bekerja di repo lain, ulangi 'start_task' dengan projectDir yang benar.`;
+  }
+
+  return { message };
+}
 
 export async function handleStartTask(args, workflowState) {
   // Selamatkan dulu pekerjaan yang mungkin tertimpa. Ini menangani dua kasus:
@@ -17,6 +83,8 @@ export async function handleStartTask(args, workflowState) {
   workflowState.state.commitAndPushCompleted = false;
   workflowState.state.lastCommitMessage = "";
   workflowState.state.lastPushBranch = "";
+  // Setelah reset(), karena reset mengosongkan projectDir.
+  const project = pinProjectDir(args, workflowState);
   // start_task memang bermaksud MENGGANTI task, jadi ia boleh menang atas
   // task berjalan. Task yang diganti tetap diarsipkan oleh reconcileWithDisk,
   // bukan dihapus.
@@ -47,7 +115,7 @@ export async function handleStartTask(args, workflowState) {
   const warningBlock = warnings.length > 0 ? `\n\n${warnings.join("\n\n")}` : "";
 
   return textResponse(
-    `✅ Task Started: ${args.description}${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🎯 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!`
   );
 }
 

package/workflow-state.js

@@ -624,6 +624,9 @@ export class WorkflowState {
       commitAndPushCompleted: false,
       lastCommitMessage: "",
       lastPushBranch: "",
+      // Repo proyek untuk sesi ini. Ditentukan saat start_task, dipakai semua
+      // operasi git berikutnya. Kosong berarti ikuti urutan resolusi di exec.js.
+      projectDir: "",
       featureFlowCreated: false,
       featureFlowDescription: "",
       history: [],
@@ -665,6 +668,9 @@ export class WorkflowState {
       commitAndPushCompleted: false,
       lastCommitMessage: "",
       lastPushBranch: "",
+      // Repo proyek untuk sesi ini. Ditentukan saat start_task, dipakai semua
+      // operasi git berikutnya. Kosong berarti ikuti urutan resolusi di exec.js.
+      projectDir: "",
       featureFlowCreated: false,
       featureFlowDescription: "",
       history: [],
@@ -724,6 +730,9 @@ export class WorkflowState {
       if (typeof this.state.lastPushBranch !== "string") {
         this.state.lastPushBranch = "";
       }
+      if (typeof this.state.projectDir !== "string") {
+        this.state.projectDir = "";
+      }
       if (typeof this.state.featureFlowCreated !== "boolean") {
         this.state.featureFlowCreated = false;
       }
@@ -1174,6 +1183,9 @@ export class WorkflowState {
       commitAndPushCompleted: false,
       lastCommitMessage: "",
       lastPushBranch: "",
+      // Repo proyek untuk sesi ini. Ditentukan saat start_task, dipakai semua
+      // operasi git berikutnya. Kosong berarti ikuti urutan resolusi di exec.js.
+      projectDir: "",
       featureFlowCreated: false,
       featureFlowDescription: "",
       history,