@programinglive/dev-workflow-mcp-server 1.13.12 → 1.13.14

package/factory-client.js

@@ -25,6 +25,7 @@ import os from "os";
 import { assertSafeKnowledge } from './security/policy.js';
 import { sanitize } from './security/sanitizer.js';
 import { registerRuntimeSecret } from './security/runtime-secrets.js';
+import { refreshFactoryCredentials, describeLoginFailure } from './factory-credentials.js';
 import { mkdirSync, readFileSync, writeFileSync } from "fs";
 import path from "path";
 
@@ -397,6 +398,27 @@ export function buildWorkFinishPayload({ sessionId, deviceId, outcome, summary,
 // HTTP layer
 // ---------------------------------------------------------------------------
 
+/**
+ * Kapan proses MCP ini hidup.
+ *
+ * Dipakai di pesan gagal login: tanpa ini pengguna tidak punya cara tahu bahwa
+ * environment yang dipakai sudah usang.
+ */
+function processStartedAt() {
+  return new Date(Date.now() - process.uptime() * 1000);
+}
+
+/** Satu percobaan login dengan pasangan email/password tertentu. */
+function attemptLogin(config, fetchImpl, { email, password }) {
+  registerRuntimeSecret(password);
+
+  return fetchImpl(`${config.pocketBaseUrl}/api/collections/activity_users/auth-with-password`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ identity: email, password }),
+  });
+}
+
 async function resolveToken(config, fetchImpl = fetch) {
   registerRuntimeSecret(config.token); registerRuntimeSecret(config.password);
   if (config.token) return config.token;
@@ -405,24 +427,57 @@ async function resolveToken(config, fetchImpl = fetch) {
   const cached = tokenCache.get(key);
   if (cached && cached.expiresAt > Date.now()) return cached.token;
 
-  const response = await fetchImpl(`${config.pocketBaseUrl}/api/collections/activity_users/auth-with-password`, {
-    method: "POST",
-    headers: { "content-type": "application/json" },
-    body: JSON.stringify({ identity: config.email, password: config.password }),
-  });
+  const remember = (token) => {
+    registerRuntimeSecret(token);
+    tokenCache.set(key, { token, expiresAt: Date.now() + TOKEN_TTL_MS });
+    return token;
+  };
 
-  if (!response.ok) {
-    throw new Error(
-      `Factory login failed (HTTP ${response.status}). Check FACTORY_EMAIL and FACTORY_PASSWORD, or set FACTORY_TOKEN.`,
-    );
+  const response = await attemptLogin(config, fetchImpl, config);
+
+  if (response.ok) {
+    const body = await response.json();
+    if (!body.token) throw new Error("Factory login returned no token.");
+    return remember(body.token);
   }
 
-  const body = await response.json();
-  if (!body.token) throw new Error("Factory login returned no token.");
-  registerRuntimeSecret(body.token);
+  // Kredensial ditolak. Sebelum menyerah, baca ulang berkas konfigurasi: proses
+  // MCP mewarisi environment saat dijalankan dan tidak pernah memuat ulang, jadi
+  // password yang baru diubah di opencode.json tidak pernah terpakai sampai
+  // OpenCode di-restart. 31 Oktober 2026 itu mematikan otomasi berjam-jam.
+  const refreshed = refreshFactoryCredentials(config);
+
+  if (refreshed && refreshed.changed) {
+    if (refreshed.token) {
+      return remember(refreshed.token);
+    }
+
+    if (refreshed.email && refreshed.password) {
+      const retry = await attemptLogin(config, fetchImpl, refreshed);
+
+      if (retry.ok) {
+        const body = await retry.json();
+        if (!body.token) throw new Error("Factory login returned no token.");
+        return remember(body.token);
+      }
+
+      throw new Error(
+        describeLoginFailure({
+          status: retry.status,
+          processStartedAt: processStartedAt(),
+          credentialsChanged: true,
+        }),
+      );
+    }
+  }
 
-  tokenCache.set(key, { token: body.token, expiresAt: Date.now() + TOKEN_TTL_MS });
-  return body.token;
+  throw new Error(
+    describeLoginFailure({
+      status: response.status,
+      processStartedAt: processStartedAt(),
+      credentialsChanged: Boolean(refreshed && refreshed.changed),
+    }),
+  );
 }
 
 /** Test helper: forget cached tokens (for example after a password change). */

package/factory-credentials.js

@@ -0,0 +1,156 @@
+/**
+ * Membaca ulang kredensial Factory dari berkas konfigurasi OpenCode.
+ *
+ * Kenapa perlu: proses MCP mewarisi environment saat ia di-spawn dan tidak
+ * pernah memuat ulang. 31 Oktober 2026 otomasi Factory mati berjam-jam dengan
+ * pesan "login failed (HTTP 400). Check FACTORY_EMAIL and FACTORY_PASSWORD"
+ * padahal password di `~/.config/opencode/opencode.json` sudah benar dan login
+ * langsung ke PocketBase menjawab 200. Penyebabnya: proses MCP hidup sejak
+ * 30 Oktober dan memegang password LAMA di memorinya.
+ *
+ * Modul ini TIDAK menyimpan rahasia baru ke disk. Ia hanya membaca berkas yang
+ * sudah ada dan sudah berisi rahasia itu.
+ */
+
+import { readFileSync } from "fs";
+import os from "os";
+import path from "path";
+
+/** Nama server di blok `mcp` pada konfigurasi OpenCode. */
+export const DEFAULT_SERVER_NAME = "dev-workflow";
+
+/**
+ * Berkas kredensial bawaan: konfigurasi OpenCode.
+ *
+ * Bisa diarahkan lewat `FACTORY_CREDENTIALS_FILE` bila konfigurasinya di tempat
+ * lain (misalnya berkas khusus tanpa isi lain).
+ */
+export function defaultCredentialsFile(env = process.env) {
+  const explicit = clean(env.FACTORY_CREDENTIALS_FILE);
+  if (explicit) return explicit;
+
+  const home = clean(env.HOME) || clean(env.USERPROFILE) || os.homedir();
+  const configHome = clean(env.XDG_CONFIG_HOME) || path.join(home, ".config");
+
+  return path.join(configHome, "opencode", "opencode.json");
+}
+
+function clean(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+
+/**
+ * Mengambil blok `environment` milik server MCP kita dari teks konfigurasi.
+ *
+ * Dua bentuk didukung, karena keduanya ada di lapangan:
+ *   { mcp: { "<nama>": {...} } }            (konfigurasi lama)
+ *   { mcp: { servers: { "<nama>": {...} } } } (konfigurasi OpenCode di mesin ini)
+ *
+ * Mengembalikan null bila teks bukan JSON, tidak punya `mcp`, atau tidak punya
+ * blok server yang diminta. Mengambil server LAIN akan lebih buruk daripada
+ * tidak mengambil apa pun: kredensial proyek lain bisa terpakai.
+ */
+export function extractFactoryEnv(text, { serverName = DEFAULT_SERVER_NAME } = {}) {
+  let parsed;
+
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return null;
+  }
+
+  const mcp = parsed && parsed.mcp;
+  if (!mcp || typeof mcp !== "object") return null;
+
+  const block = mcp[serverName] || (mcp.servers && mcp.servers[serverName]);
+  if (!block || typeof block !== "object") return null;
+
+  const environment = block.environment;
+  if (!environment || typeof environment !== "object") return null;
+
+  return environment;
+}
+
+/**
+ * Membandingkan kredensial yang sedang dipakai proses dengan yang ada di berkas.
+ *
+ * Mengembalikan null bila tidak ada yang bisa disegarkan (berkas tidak ada,
+ * rusak, atau tanpa blok server kita). Selain itu objek dengan kredensial
+ * TERBARU, plus `changed` yang menandakan apakah ia berbeda dari yang dipakai.
+ */
+export function refreshFactoryCredentials(
+  config = {},
+  { env = process.env, readFileImpl = readFileSync, serverName = DEFAULT_SERVER_NAME } = {}
+) {
+  const file = defaultCredentialsFile(env);
+
+  let text;
+  try {
+    text = String(readFileImpl(file, "utf8"));
+  } catch {
+    return null;
+  }
+
+  const environment = extractFactoryEnv(text, { serverName });
+  if (!environment) return null;
+
+  const token = clean(environment.FACTORY_TOKEN);
+  const email = clean(environment.FACTORY_EMAIL);
+  const password = clean(environment.FACTORY_PASSWORD);
+
+  const current = {
+    token: clean(config.token),
+    email: clean(config.email),
+    password: clean(config.password),
+  };
+
+  const changed =
+    token !== current.token || email !== current.email || password !== current.password;
+
+  return {
+    token,
+    email,
+    password,
+    changed,
+    source: "file",
+    file,
+  };
+}
+
+/**
+ * Pesan gagal login yang bisa ditindaklanjuti.
+ *
+ * Dua hal yang membedakannya dari pesan lama ("check FACTORY_EMAIL and
+ * FACTORY_PASSWORD"): ia menyebut KAPAN proses ini hidup, dan ia menyebut
+ * apakah kredensial di berkas berbeda dari yang sedang dipakai. Tanpa itu,
+ * pengguna disuruh memeriksa password yang sebenarnya sudah benar.
+ */
+export function describeLoginFailure({ status, processStartedAt, credentialsChanged = false }) {
+  const started = processStartedAt instanceof Date ? processStartedAt.toISOString() : "";
+
+  const lines = [
+    `Factory login failed (HTTP ${status}).`,
+    started
+      ? `Proses MCP ini hidup sejak ${started} dan memakai environment yang diwarisi saat itu - ia tidak pernah memuat ulang berkas konfigurasi.`
+      : "Proses MCP ini memakai environment yang diwarisi saat ia dijalankan.",
+  ];
+
+  if (credentialsChanged) {
+    lines.push(
+      "Kredensial di berkas konfigurasi BERBEDA dari yang sedang dipakai proses ini. " +
+        "Kredensial terbaru sudah dicoba dan tetap ditolak, jadi kemungkinan besar " +
+        "password-nya memang salah, atau akunnya belum bisa login."
+    );
+  } else {
+    lines.push(
+      "Kredensial di berkas konfigurasi SAMA dengan yang dipakai, atau berkasnya tidak ditemukan."
+    );
+  }
+
+  lines.push(
+    "Periksa FACTORY_EMAIL/FACTORY_PASSWORD, atau set FACTORY_TOKEN. " +
+      "Bila password baru saja diubah, restart OpenCode agar proses MCP memakai kredensial terbaru."
+  );
+
+  return lines.join(" ");
+}

package/git-facade.js

@@ -16,6 +16,7 @@ import {
   getRemoteBranchSha,
   getStagedChanges,
   getStatusOutput,
+  getToplevel,
   hasStagedChanges,
   hasTestChanges,
   hasWorkingChanges,
@@ -34,6 +35,7 @@ export function createGitFacade() {
     getRemoteBranchSha,
     getLastCommitMessage,
     getStatusOutput,
+    getToplevel,
     workingTreeSummary,
   };
 }

package/git-helpers.js

@@ -173,6 +173,18 @@ export async function getStatusOutput() {
   return stdout;
 }
 
+/**
+ * Direktori teratas repo tempat git BENAR-BENAR berjalan.
+ *
+ * `git rev-parse --show-toplevel` menjawab dari repo yang aktif, bukan dari
+ * tebakan kita tentang direktori mana yang dimaksud. Dipakai untuk memastikan
+ * laporan `commit_and_push` menyebut repo yang sama dengan yang di-commit.
+ */
+export async function getToplevel() {
+  const { stdout } = await exec("git rev-parse --show-toplevel");
+  return stdout.trim();
+}
+
 export async function getPrimaryBranch() {
   try {
     // Check if 'main' exists on origin

package/index.js

@@ -13,6 +13,8 @@ import {
   GetPromptRequestSchema,
 } from "@modelcontextprotocol/sdk/types.js";
 import { fileURLToPath } from "url";
+import path from "path";
+import { acquireProcessLock, releaseProcessLock, lockWarning } from "./process-lock.js";
 import { exec, setActiveProjectDir } from "./exec.js";
 import { normalizeRequestArgs, shellEscape } from "./utils.js";
 import { createGitFacade } from "./git-facade.js";
@@ -197,6 +199,20 @@ export async function main() {
     // Select request metadata before the first disk write. Creating an idle
     // PID fallback here leaves a phantom session alongside the real sessions.
     safeLog('error', `[${new Date().toISOString()}] Workflow state initialization complete.`);
+
+    // Penanda proses: 31 Oktober 2026 dua proses MCP hidup bersamaan dan
+    // memegang kredensial Factory yang berbeda, sehingga tool yang sama
+    // menjawab berbeda tergantung proses mana yang melayaninya. Proses lain
+    // TIDAK dibunuh (itu berbahaya); cukup dilaporkan supaya pengguna tahu
+    // harus menutup OpenCode dan membukanya lagi.
+    try {
+      const stateDir = path.dirname(path.resolve(workflowState.stateFile));
+      const warning = lockWarning(acquireProcessLock({ dir: stateDir }));
+      if (warning) safeLog('error', warning);
+      process.once('exit', () => releaseProcessLock({ dir: stateDir }));
+    } catch (lockError) {
+      safeLog('error', 'Warning: could not record process lock:', lockError.message);
+    }
   } catch (error) {
     safeLog('error', `[${new Date().toISOString()}] Warning: Failed to initialize workflow state:`, error.message);
     // Continue anyway - workflow state is optional for MCP to function

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@programinglive/dev-workflow-mcp-server",
-  "version": "1.13.12",
+  "version": "1.13.14",
   "description": "MCP server to enforce development workflow discipline",
   "homepage": "https://devworkflow.programinglive.com/",
   "mcpName": "io.github.programinglive/dev-workflow-mcp-server",
@@ -21,7 +21,7 @@
     "start": "node index.js",
     "local": "node index.js",
     "setup": "node scripts/setup-stack.js",
-    "test": "node --no-deprecation --test",
+    "test": "node --no-deprecation --import ./tests/setup-env.js --test",
     "test:security": "node --no-deprecation --test tests/security*.test.js",
     "security:audit": "node index.js call security_audit",
     "lint": "node scripts/lint.mjs",

package/process-lock.js

@@ -0,0 +1,134 @@
+/**
+ * Satu penanda "proses MCP mana yang sedang hidup" per direktori state.
+ *
+ * Kenapa perlu: 31 Oktober 2026 ada DUA proses dev-workflow MCP hidup
+ * bersamaan. Yang lebih tua memegang password Factory lama di memorinya, yang
+ * lebih muda memegang yang baru, jadi tool yang sama menjawab berbeda
+ * tergantung proses mana yang melayaninya - dan keduanya menulis berkas state
+ * workflow yang sama.
+ *
+ * Modul ini TIDAK membunuh proses lain. Membunuh proses secara otomatis adalah
+ * tindakan berbahaya (ada guard tersendiri untuk itu). Yang dilakukan: proses
+ * kedua mengetahui bahwa ia bukan satu-satunya, lalu melaporkannya, sehingga
+ * pengguna bisa menutup OpenCode dan memulai ulang dengan bersih.
+ */
+
+import { existsSync, readFileSync, writeFileSync, unlinkSync, mkdirSync } from "fs";
+import os from "os";
+import path from "path";
+
+export const LOCK_FILENAME = "mcp-process.lock";
+
+/** Lokasi berkas lock untuk satu direktori state. */
+export function processLockPath({ dir }) {
+  return path.join(dir, LOCK_FILENAME);
+}
+
+/**
+ * Membaca isi lock, atau null bila tidak ada / tidak terbaca.
+ *
+ * Berkas rusak sengaja dianggap "tidak ada lock": penanda yang tidak bisa
+ * dibaca tidak boleh membuat server gagal start. Lebih baik dua proses
+ * bertabrakan daripada server tidak hidup sama sekali.
+ */
+export function readProcessLock({ dir }) {
+  const file = processLockPath({ dir });
+
+  if (!existsSync(file)) return null;
+
+  try {
+    const parsed = JSON.parse(readFileSync(file, "utf8"));
+    if (!parsed || typeof parsed.pid !== "number") return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+
+function defaultIsAlive(pid) {
+  if (!Number.isFinite(pid) || pid <= 0) return false;
+
+  try {
+    // Sinyal 0 tidak mengirim apa pun; ia hanya memeriksa apakah proses ada.
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    // EPERM berarti proses ADA tetapi milik pengguna lain.
+    return error && error.code === "EPERM";
+  }
+}
+
+/**
+ * Mencoba menjadi pemegang lock.
+ *
+ * Mengembalikan:
+ *   { acquired: true }                        -> kita pemegangnya
+ *   { acquired: true, tookOverFrom: <pid> }   -> pemegang lama sudah mati
+ *   { acquired: false, holder: {...} }        -> ada proses lain yang hidup
+ */
+export function acquireProcessLock({ dir, pid = process.pid, now = Date.now(), isAlive = defaultIsAlive }) {
+  const existing = readProcessLock({ dir });
+
+  if (existing && existing.pid !== pid && isAlive(existing.pid)) {
+    return { acquired: false, holder: existing };
+  }
+
+  const tookOverFrom = existing && existing.pid !== pid ? existing.pid : undefined;
+
+  const payload = { pid, startedAt: now, host: safeHostname() };
+
+  try {
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(processLockPath({ dir }), JSON.stringify(payload), "utf8");
+  } catch {
+    // Tidak bisa menulis penanda bukan alasan mematikan server.
+    return { acquired: true, wrote: false };
+  }
+
+  return tookOverFrom ? { acquired: true, tookOverFrom } : { acquired: true };
+}
+
+/** Melepas lock hanya bila memang milik kita. */
+export function releaseProcessLock({ dir, pid = process.pid }) {
+  const existing = readProcessLock({ dir });
+
+  if (!existing || existing.pid !== pid) return false;
+
+  try {
+    unlinkSync(processLockPath({ dir }));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function safeHostname() {
+  try {
+    return os.hostname();
+  } catch {
+    return "";
+  }
+}
+
+/**
+ * Pesan yang dicatat saat proses lain sudah memegang lock, atau null bila tidak
+ * ada yang perlu dilaporkan.
+ *
+ * Dipisah dari `acquireProcessLock` supaya bisa diuji tanpa menyentuh proses
+ * nyata, dan supaya pemanggil bebas memilih tidak menampilkan apa pun.
+ */
+export function lockWarning(result) {
+  if (!result || result.acquired !== false || !result.holder) return null;
+
+  const started = Number.isFinite(result.holder.startedAt)
+    ? new Date(result.holder.startedAt).toISOString()
+    : "waktu tidak diketahui";
+
+  return (
+    `Proses dev-workflow MCP lain (PID ${result.holder.pid}, hidup sejak ${started}) ` +
+    "masih berjalan dan memakai direktori state yang sama. " +
+    "Proses yang lebih tua memegang environment saat ia dijalankan, jadi kredensial Factory " +
+    "dan state workflow bisa berbeda antar proses. Tutup OpenCode lalu buka lagi untuk " +
+    "memastikan hanya satu proses yang hidup."
+  );
+}

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

@@ -2,6 +2,7 @@ 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";
+import path from "path";
 
 /**
  * Label repo yang benar-benar dipakai, untuk ditampilkan di setiap jawaban.
@@ -24,6 +25,18 @@ function repoLabel() {
   }
 }
 
+/**
+ * Apakah dua path menunjuk direktori yang sama.
+ *
+ * Windows tidak membedakan huruf besar/kecil dan kadang memberi garis miring
+ * di akhir, jadi perbandingan string mentah akan salah.
+ */
+function samePath(a, b) {
+  if (!a || !b) return false;
+  const normal = (value) => path.resolve(value).replace(/[\\/]+$/, "").toLowerCase();
+  return normal(a) === normal(b);
+}
+
 /**
  * Terapkan `projectDir` dari argumen tool bila ada.
  * Mengembalikan pesan kesalahan, atau null bila tidak ada masalah.
@@ -127,10 +140,21 @@ export async function handleCommitAndPush(args, context) {
   let primaryBranch;
   let currentBranch;
   let hasWorkingChanges;
+  let gitToplevel = "";
   try {
     primaryBranch = await git.getPrimaryBranch();
     currentBranch = await git.getCurrentBranch();
     hasWorkingChanges = await git.hasWorkingChanges();
+
+    // Tempat git BENAR-BENAR berjalan, menurut git sendiri.
+    //
+    // 31 Oktober 2026 laporan menyebut `portal-beautyworld` untuk commit yang
+    // masuk ke repo lain, karena labelnya dibaca dari variabel global yang bisa
+    // berubah - bukan dari repo tempat git berjalan. Laporan seperti itu membuat
+    // agen percaya commit-nya ada di tempat yang salah.
+    if (typeof git.getToplevel === "function") {
+      gitToplevel = String((await git.getToplevel()) || "").trim();
+    }
   } catch (error) {
     return textResponse(
       `❌ Tidak bisa memeriksa repository Git, jadi tidak ada yang di-commit.\n\n` +
@@ -140,6 +164,22 @@ export async function handleCommitAndPush(args, context) {
     );
   }
 
+  // Kalau git berjalan di repo lain daripada yang diminta, BERHENTI. Commit ke
+  // repo yang salah jauh lebih mahal daripada satu pesan kesalahan.
+  const requestedRepo = getActiveProjectDir();
+  if (gitToplevel && requestedRepo && !samePath(gitToplevel, requestedRepo)) {
+    return textResponse(
+      `❌ Dibatalkan: git berjalan di repo yang BERBEDA dari yang diminta.\n\n` +
+      `Diminta    : ${requestedRepo}\n` +
+      `Dipakai git: ${gitToplevel}\n\n` +
+      `Tidak ada yang di-commit. Sebutkan 'projectDir' yang benar pada 'commit_and_push', ` +
+      `atau jalankan ulang 'start_task' dengan 'projectDir' repo tersebut.`
+    );
+  }
+
+  // Label laporan memakai repo yang benar-benar dipakai git bila diketahui.
+  const repoName = gitToplevel || repoLabel();
+
   const branchForPush = pickPushBranch({ requestedBranch, currentBranch, primaryBranch });
 
   if (!hasWorkingChanges) {
@@ -153,7 +193,7 @@ export async function handleCommitAndPush(args, context) {
     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` +
+        `Repo: ${repoName}\nBranch: ${branchForPush || "(tidak diketahui)"}\n` +
         `Sebab: ${pushed.detail}\n\n` +
         `Jalankan 'commit_and_push' lagi dengan 'branch' yang benar, atau push manual.`
       );
@@ -166,7 +206,7 @@ export async function handleCommitAndPush(args, context) {
     await workflowState.save();
 
     return textResponse(
-      `ℹ️ No changes detected. Assuming commit and push already completed.\nRepo: ${repoLabel()}\nBranch: ${branchForPush} (verified on remote)\nLast commit: ${effectiveCommitMessage || "(unavailable)"
+      `ℹ️ No changes detected. Assuming commit and push already completed.\nRepo: ${repoName}\nBranch: ${branchForPush} (verified on remote)\nLast commit: ${effectiveCommitMessage || "(unavailable)"
       }\n\nNext: Run 'perform_release' to handle the release and push tags.`
     );
   }
@@ -228,7 +268,7 @@ export async function handleCommitAndPush(args, context) {
   if (!pushed.ok) {
     return textResponse(
       `❌ Commit dibuat, tetapi TIDAK ter-push.\n` +
-      `Repo: ${repoLabel()}\nBranch: ${branchForPush || "(tidak diketahui)"}\n` +
+      `Repo: ${repoName}\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.`
@@ -242,7 +282,7 @@ export async function handleCommitAndPush(args, context) {
   await workflowState.save();
 
   return textResponse(
-    `✅ 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.`
+    `✅ Commit and push completed!\nRepo: ${repoName}\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,6 +1,42 @@
 import { textResponse, isReleaseSatisfied, resetToCommitIfWorkingChanges, summarizeHistory } from "./shared.js";
 import { resolveProjectDir, setActiveProjectDir, getActiveProjectDir } from "../../exec.js";
 
+/**
+ * Label repo yang dipakai, untuk ditampilkan di laporan.
+ *
+ * Sama seperti di commit-handlers: laporan harus menyebut repo yang benar-benar
+ * dipakai, bukan tebakan.
+ */
+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)";
+  }
+}
+
+/**
+ * Menjalankan perintah git yang hasilnya hanya dipakai untuk laporan.
+ *
+ * Kegagalan di sini tidak boleh menggagalkan rilis: kalau `git describe`
+ * tidak menemukan tag, itu bukan alasan untuk berhenti. Yang penting adalah
+ * rilis tetap berjalan dan laporannya jujur tentang apa yang tidak diketahui.
+ */
+async function safeExecStdout(exec, command) {
+  try {
+    const { stdout } = await exec(command);
+    return String(stdout || "").trim();
+  } catch {
+    return "";
+  }
+}
+
 export async function handleSkipRelease(args, workflowState) {
   if (workflowState.state.currentPhase === "idle") {
     return textResponse("⚠️ Please start a task first using 'start_task' before skipping release.");
@@ -185,11 +221,45 @@ export async function handlePerformRelease(args, context) {
     );
   }
 
+  // Tipe rilis WAJIB sah sebelum perintah disusun.
+  //
+  // 31 Oktober 2026: `determineReleaseTypeFromCommit` mengembalikan string kosong,
+  // lalu perintahnya menjadi `npm run release -- --release-as ` + "null" ->
+  // standard-version menulis `"version": null` dan membuat tag `vnull`, lalu
+  // keduanya di-push. Yang salah bukan hanya hasilnya: perintah yang mustahil
+  // itu tetap dijalankan tanpa perlawanan.
+  if (!recognizedTypes.has(releaseType)) {
+    return textResponse(
+      `⚠️ Tipe rilis tidak bisa ditentukan dari commit terakhir, jadi rilis TIDAK dijalankan.\n\n` +
+      `Commit terakhir: ${lastCommitMessage || "(kosong)"}\n\n` +
+      `Sebutkan tipe rilisnya secara eksplisit:\n` +
+      `  • 'perform_release' dengan releaseType: "patch" | "minor" | "major"\n` +
+      `  • atau command: "npm run release:patch"\n\n` +
+      `Tanpa itu perintahnya akan menjadi "--release-as null", yang menghasilkan tag vnull ` +
+      `dan package.json berversi null.`
+    );
+  }
+
   const finalCommand =
     releaseCommand.includes("--release-as") || /release:(major|minor|patch)/i.test(releaseCommand)
       ? releaseCommand
       : `${releaseCommand} -- --release-as ${releaseType}`;
 
+  // Jaring pengaman terakhir: apa pun yang terjadi di atas, jangan pernah
+  // menjalankan perintah yang membawa tipe rilis kosong.
+  if (/--release-as\s+(?:null|undefined|)\s*$/i.test(finalCommand) || /\snull\b/i.test(finalCommand)) {
+    return textResponse(
+      `⚠️ Perintah rilis akan berisi tipe rilis yang tidak sah, jadi TIDAK dijalankan:\n\n` +
+      `  ${finalCommand}\n\n` +
+      `Sebutkan tipe rilisnya: releaseType "patch" | "minor" | "major".`
+    );
+  }
+
+  // Catat keadaan SEBELUM rilis supaya, kalau push gagal, kita bisa menyebut
+  // persis apa yang tertinggal di mesin.
+  const headBefore = await safeExecStdout(exec, "git rev-parse HEAD");
+  const tagBefore = await safeExecStdout(exec, "git describe --tags --abbrev=0");
+
   try {
     await exec(finalCommand);
   } catch (error) {
@@ -198,6 +268,9 @@ export async function handlePerformRelease(args, context) {
     );
   }
 
+  const headAfter = await safeExecStdout(exec, "git rev-parse HEAD");
+  const tagAfter = await safeExecStdout(exec, "git describe --tags --abbrev=0");
+
   const branchForPush = workflowState.state.lastPushBranch || (await git.getCurrentBranch()) || "";
   const pushCommand = branchForPush
     ? `git push --follow-tags origin ${utils.shellEscape(branchForPush)}`
@@ -206,8 +279,29 @@ export async function handlePerformRelease(args, context) {
   try {
     await exec(pushCommand);
   } catch (error) {
+    // Rilis SUDAH membuat commit dan tag di mesin; hanya push yang gagal.
+    // Tanpa menyebut yang tertinggal, tidak jelas apa yang harus dibereskan -
+    // dan pada 31 Oktober 2026 hal itu membuat rilis tampak selesai.
+    const leftBehind = [];
+    if (headAfter && headAfter !== headBefore) {
+      leftBehind.push(`  • commit rilis ${headAfter.slice(0, 8)}`);
+    }
+    if (tagAfter && tagAfter !== tagBefore) {
+      leftBehind.push(`  • tag ${tagAfter}`);
+    }
+
     return textResponse(
-      `❌ git push (with tags) failed:\n\n${error.stderr || error.stdout || error.message}`
+      `❌ Push rilis GAGAL. Rilis TIDAK tercatat sebagai selesai.\n\n` +
+      `Repo: ${repoLabel()}\nBranch: ${branchForPush || "(tidak diketahui)"}\n` +
+      `Penyebab: ${error.stderr || error.stdout || error.message}\n\n` +
+      (leftBehind.length > 0
+        ? `Tertinggal di mesin (belum sampai ke remote):\n${leftBehind.join("\n")}\n\n`
+        : "") +
+      `Pemulihan:\n` +
+      `  1. periksa: git log --oneline -3 && git tag --points-at HEAD\n` +
+      `  2. kirim ulang: git push --follow-tags origin ${branchForPush || "<branch>"}\n` +
+      `  3. atau batalkan rilis lokal: git reset --hard HEAD~1 && git tag -d ${tagAfter || "<tag>"}\n\n` +
+      `Jangan tandai task selesai sebelum tag benar-benar ada di remote.`
     );
   }
 

package/workflow-state.js

@@ -400,6 +400,19 @@ async function pathExists(filePath) {
 }
 
 async function ensureCompatibilityLinks(primaryPath) {
+  // Cermin kompatibilitas ditulis ke `<paket>/.state/workflow-state.json`,
+  // BUKAN ke lokasi state yang sebenarnya. Itu benar untuk pemakaian nyata
+  // (CLI dan dasbor web membaca jalur lama), tetapi merusak saat tes: setiap
+  // WorkflowState yang dibuat tes - meski di direktori sementara - menimpa
+  // state repo, dan 31 Oktober 2026 itu menghapus task yang sedang berjalan di
+  // tengah `npm test`.
+  //
+  // Tes mematikan cermin ini lewat DEV_WORKFLOW_NO_COMPAT_LINKS=1 (lihat
+  // tests/setup-env.js). Perilaku produksi tidak berubah.
+  if (process.env.DEV_WORKFLOW_NO_COMPAT_LINKS === "1") {
+    return;
+  }
+
   const resolvedPrimary = path.resolve(primaryPath);
 
   if (!(await pathExists(resolvedPrimary))) {