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

package/factory-client.js

@@ -22,6 +22,9 @@
 
 import { createHash, randomUUID } from "crypto";
 import os from "os";
+import { assertSafeKnowledge } from './security/policy.js';
+import { sanitize } from './security/sanitizer.js';
+import { registerRuntimeSecret } from './security/runtime-secrets.js';
 import { mkdirSync, readFileSync, writeFileSync } from "fs";
 import path from "path";
 
@@ -36,6 +39,34 @@ export const VALID_STATUSES = ["backlog", "queued", "running", "review", "blocke
 /** Statuses reachable by finishing a work session, and the matching outcome. */
 const WORK_OUTCOMES = { review: "review", blocked: "blocked", paused: "paused" };
 
+/**
+ * Event kinds yang menentukan apakah sebuah task sudah dilaporkan selesai.
+ *
+ * `work.paused` ikut diperhitungkan karena itu satu-satunya jalan resmi
+ * mengembalikan task dari review ke backlog. Kalau event terakhir adalah
+ * paused, pekerjaan memang sedang dikerjakan ulang dan review baru sah.
+ */
+export const REVIEW_GATE_KINDS = ["work.review", "task.done", "work.paused"];
+
+/**
+ * Mengembalikan event yang memblokir laporan review, atau null bila boleh.
+ *
+ * Memblokir bila event terakhir adalah review/done: Factory membacanya sebagai
+ * approval. Membiarkan bila event terakhir adalah paused (pekerjaan ulang).
+ * Toleran terhadap workspace lama tanpa `events`.
+ */
+export function findBlockingReviewEvent(events, taskId) {
+  if (!Array.isArray(events) || !taskId) return null;
+
+  const relevant = events
+    .filter((event) => event && event.targetId === taskId && REVIEW_GATE_KINDS.includes(event.kind))
+    .sort((a, b) => String(a.createdAt || "").localeCompare(String(b.createdAt || "")));
+
+  const last = relevant[relevant.length - 1];
+  if (!last) return null;
+  return last.kind === "work.paused" ? null : last;
+}
+
 /** Statuses reachable through POST /api/factory { action: move_task }. */
 const MOVABLE_STATUSES = ["backlog", "queued", "cancelled", "done"];
 
@@ -82,6 +113,7 @@ export function readFactoryConfig(env = process.env) {
   const email = clean(env.FACTORY_EMAIL);
   const password = clean(env.FACTORY_PASSWORD);
   if (!token && !(email && password)) return null;
+  registerRuntimeSecret(token); registerRuntimeSecret(password);
 
   return {
     url: trimSlash(url),
@@ -229,6 +261,7 @@ export function mapTaskRecord(record = {}, projects = []) {
     projectName: byId.get(record.projectId) ?? null,
     description: record.description || null,
     acceptance: record.acceptance || null,
+    definitionOfDone: record.definitionOfDone || null,
     createdAt: record.createdAt ?? null,
     updatedAt: record.updatedAt ?? null,
     work: work
@@ -267,13 +300,17 @@ export function formatTaskList(tasks = []) {
 
   tasks.forEach((task, index) => {
     const meta = [task.status, task.priority, task.projectName].filter(Boolean).join(" · ");
-    lines.push(`${index + 1}. [${task.taskKey || task.id}] ${task.title}`);
+    // UUID penuh, bukan potongan 8 karakter: `sync_task_status` menuntut UUID,
+    // dan sebelumnya agen harus membaca API sendiri untuk mendapatkannya.
+    const label = task.id || task.taskKey || "tanpa-id";
+    lines.push(`${index + 1}. [${label}] ${task.title}`);
     if (meta) lines.push(`   ${meta}`);
     if (task.work?.state === "active") {
       const who = task.work.deviceName ? ` on ${task.work.deviceName}` : "";
       lines.push(`   active session${who}${task.work.step ? `: ${task.work.step}` : ""}`);
     }
     if (task.acceptance) lines.push(`   acceptance: ${firstLine(task.acceptance)}`);
+    if (task.definitionOfDone) lines.push(`   DoD: ${firstLine(task.definitionOfDone)}`);
   });
 
   return lines.join("\n");
@@ -361,6 +398,7 @@ export function buildWorkFinishPayload({ sessionId, deviceId, outcome, summary,
 // ---------------------------------------------------------------------------
 
 async function resolveToken(config, fetchImpl = fetch) {
+  registerRuntimeSecret(config.token); registerRuntimeSecret(config.password);
   if (config.token) return config.token;
 
   const key = `${config.pocketBaseUrl}|${config.email}`;
@@ -381,6 +419,7 @@ async function resolveToken(config, fetchImpl = fetch) {
 
   const body = await response.json();
   if (!body.token) throw new Error("Factory login returned no token.");
+  registerRuntimeSecret(body.token);
 
   tokenCache.set(key, { token: body.token, expiresAt: Date.now() + TOKEN_TTL_MS });
   return body.token;
@@ -392,6 +431,11 @@ export function clearTokenCache() {
 }
 
 async function request(config, path, { method = "GET", body, fetchImpl = fetch } = {}) {
+  if(body) {
+    // These are Factory work/editor record identifiers, not login sessions.
+    const {sessionId,clientSession,...knowledge}=body;
+    assertSafeKnowledge({...knowledge,workRecordId:sessionId,editorContext:clientSession});
+  }
   const token = await resolveToken(config, fetchImpl);
   const response = await fetchImpl(`${config.url}${path}`, {
     method,
@@ -411,16 +455,16 @@ async function request(config, path, { method = "GET", body, fetchImpl = fetch }
   }
 
   if (!response.ok) {
-    const detail = parsed.error || parsed.message || text || response.statusText;
+    const detail = sanitize(parsed.error || parsed.message || text || response.statusText);
     // Body dan status ikut dibawa ke pemanggil, supaya penolakan takeover
     // bisa diterjemahkan jadi arahan yang bisa dijalankan.
     const error = new Error(`Factory request failed (HTTP ${response.status}): ${detail}`);
     error.status = response.status;
-    error.body = parsed;
+    error.body = sanitize(parsed);
     throw error;
   }
 
-  return parsed;
+  return sanitize(parsed);
 }
 
 /** Reads the whole workspace: projects, tasks and events. */
@@ -510,11 +554,29 @@ export async function heartbeatWork(config, { sessionId, deviceId, step, clientS
  *
  * Factory only accepts an outcome for a session that exists and belongs to the
  * caller's device, so both are checked first to produce a clear message.
+ *
+ * Satu penjagaan tambahan: outcome `review` ditolak bila task sudah punya
+ * riwayat review. Factory membaca review kedua sebagai approval, sehingga task
+ * melompat ke `done` tanpa keputusan pemilik - persis yang terjadi 29 Okt 2026
+ * pada empat task (sesi lama sudah review, board masih backlog).
  */
 export async function finishWork(config, { taskId, outcome, summary, device } = {}, fetchImpl = fetch) {
   const deviceId = (device || deviceFromConfig(config)).id;
-  const task = await findTask(config, taskId, fetchImpl);
-  if (!task) throw new Error(`No task with id "${taskId}" is visible to this account.`);
+  const workspace = await readWorkspace(config, fetchImpl);
+  const record = (workspace.tasks || []).find((task) => task.id === taskId);
+  if (!record) throw new Error(`No task with id "${taskId}" is visible to this account.`);
+  const task = mapTaskRecord(record, workspace.projects || []);
+
+  if (outcome === "review") {
+    const prior = findBlockingReviewEvent(workspace.events, taskId);
+    if (prior) {
+      throw new Error(
+        `Task "${task.title}" sudah pernah dilaporkan untuk review (${prior.kind} pada ${prior.createdAt || "waktu tidak tercatat"}). ` +
+        "Melaporkan review kedua kali dibaca Factory sebagai approval, sehingga task bisa melompat ke done tanpa persetujuan pemilik. " +
+        "Minta pemilik memutuskan: set done bila pekerjaan diterima, atau kembalikan ke backlog bila perlu dikerjakan ulang.",
+      );
+    }
+  }
 
   const session = task.work;
   if (!session || session.state !== "active") {
@@ -541,9 +603,19 @@ export async function updateTaskStatus(config, { recordId, status, reason, nextA
   const plan = planStatusTransition(status);
 
   if (plan.kind === "move") {
+    // Factory mewajibkan alasan saat menutup task sebagai done/cancelled
+    // (minimal 3 karakter, maksimal 500). Tanpa field ini, penutupan task
+    // selalu ditolak HTTP 400 - dan karena handler mengembalikan teks alih-alih
+    // melempar, kegagalannya tampak seperti berhasil.
+    const moveReason = typeof reason === "string" ? reason.trim().slice(0, 500) : "";
     await request(config, "/api/factory", {
       method: "POST",
-      body: { action: "move_task", id: recordId, status: plan.status },
+      body: {
+        action: "move_task",
+        id: recordId,
+        status: plan.status,
+        ...(moveReason ? { reason: moveReason } : {}),
+      },
       fetchImpl,
     });
     return { id: recordId, status: plan.status };
@@ -570,6 +642,7 @@ export async function createTask(config, input = {}, fetchImpl = fetch) {
   const title = clean(input.title) || "";
   const description = clean(input.description) || "";
   const acceptance = clean(input.acceptance) || "";
+  const definitionOfDone = clean(input.definitionOfDone) || "";
   const priority = clean(input.priority) || "normal";
   const status = clean(input.status) || "backlog";
 
@@ -581,6 +654,11 @@ export async function createTask(config, input = {}, fetchImpl = fetch) {
   if (acceptance.length < 3 || acceptance.length > 3000) {
     throw new Error("acceptance must be 3-3000 characters and should state what proves the work is done.");
   }
+  if (definitionOfDone.length < 3 || definitionOfDone.length > 3000) {
+    throw new Error(
+      "definitionOfDone must be 3-3000 characters and must list what proves the task is done, for example '- [ ] build lulus'.",
+    );
+  }
   if (description.length > 4000) throw new Error("description must be at most 4000 characters.");
   if (!CREATABLE_PRIORITIES.includes(priority)) {
     throw new Error(`priority must be one of: ${CREATABLE_PRIORITIES.join(", ")}.`);
@@ -591,15 +669,69 @@ export async function createTask(config, input = {}, fetchImpl = fetch) {
 
   const body = await request(config, "/api/factory", {
     method: "POST",
-    body: { action: "create_task", task: { projectId, title, description, acceptance, priority, status } },
+    body: { action: "create_task", task: { projectId, title, description, acceptance, definitionOfDone, priority, status } },
     fetchImpl,
   });
 
   return { id: body.id ?? null, runId: body.runId ?? null, status };
 }
 
-/** Lists the owner's projects so a task can reference a real projectId. */
-export async function listProjects(config, fetchImpl = fetch) {
+/**
+ * Edits the details of an existing task.
+ *
+ * Dipakai untuk melengkapi `definitionOfDone` pada task yang dibuat sebelum
+ * kolom itu ada: Factory menolak `done` selama DoD kosong, jadi agen butuh cara
+ * mengisinya tanpa meninggalkan MCP. `expectedUpdatedAt` diambil dari workspace
+ * terbaru supaya dua agen tidak saling menimpa; Factory menjawab 409 bila basi.
+ */
+export async function updateTaskDetails(
+  config,
+  { recordId, title, description, acceptance, definitionOfDone } = {},
+  fetchImpl = fetch,
+) {
+  if (!recordId) throw new Error("recordId is required to update a task.");
+
+  const changes = {};
+
+  if (title !== undefined) {
+    const value = String(title).trim();
+    if (value.length < 3 || value.length > 140) throw new Error("title must be 3-140 characters.");
+    changes.title = value;
+  }
+
+  if (description !== undefined) {
+    const value = String(description).trim();
+    if (value.length > 4000) throw new Error("description must be at most 4000 characters.");
+    changes.description = value;
+  }
+
+  if (acceptance !== undefined) {
+    const value = String(acceptance).trim();
+    if (value.length < 3 || value.length > 3000) throw new Error("acceptance must be 3-3000 characters.");
+    changes.acceptance = value;
+  }
+
+  if (definitionOfDone !== undefined) {
+    const value = String(definitionOfDone).trim();
+    if (value.length < 3 || value.length > 3000) throw new Error("definitionOfDone must be 3-3000 characters.");
+    changes.definitionOfDone = value;
+  }
+
+  if (Object.keys(changes).length === 0) throw new Error("Provide at least one field to update.");
+
+  const task = await findTask(config, recordId, fetchImpl);
+  if (!task) throw new Error(`No task with id "${recordId}" is visible to this account.`);
+
+  const body = await request(config, "/api/factory", {
+    method: "POST",
+    body: { action: "update_task", id: recordId, expectedUpdatedAt: task.updatedAt, task: changes },
+    fetchImpl,
+  });
+
+  return { id: body.id ?? recordId, updatedAt: body.updatedAt ?? null };
+}
+
+/** Lists the owner's projects so a task can reference a real projectId. */export async function listProjects(config, fetchImpl = fetch) {
   const workspace = await readWorkspace(config, fetchImpl);
   return (workspace.projects || []).map((project) => ({
     id: project.id ?? null,

package/index.js

@@ -1,6 +1,8 @@
 #!/usr/bin/env node
 
 import "dotenv/config";
+import { safeLog, sanitize, securityOutputFilter } from './security/sanitizer.js';
+import { securityMode } from './security/policy.js';
 
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
@@ -18,7 +20,7 @@ import {
   createCommitMessageParts,
   determineReleaseTypeFromCommit,
 } from "./commit-helpers.js";
-import { WorkflowState } from "./workflow-state.js";
+import { WorkflowState, sessionKeyFromRequest } from "./workflow-state.js";
 import { getToolList } from "./tools/definitions.js";
 import { handleToolCall } from "./tools/handlers.js";
 
@@ -52,18 +54,25 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
 
 // Handle tool calls
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  try {
   // Reload state from disk before each request to ensure consistency
   if (workflowState) {
+    const sessionId = sessionKeyFromRequest(request);
+    if (sessionId) await workflowState.useSession(sessionId);
     await workflowState.load();
   }
-  return handleToolCall({
+  return securityOutputFilter(await handleToolCall({
     request,
     normalizeRequestArgs,
     workflowState,
     exec,
     git: createGitFacade(),
     utils: { shellEscape, determineReleaseTypeFromCommit, createCommitMessageParts },
-  });
+  }));
+  } catch(error) {
+    safeLog('error','MCP request failed',error);
+    return {isError:true,content:[{type:'text',text:'Request failed; inspect sanitized server diagnostics.'}]};
+  }
 });
 
 // Helper function
@@ -175,30 +184,30 @@ Use 'check_ready_to_commit' to verify workflow completion.
 
 // Start server
 export async function main() {
+  securityMode();
   const startTime = Date.now();
-  console.error(`[${new Date().toISOString()}] MCP Server starting...`);
+  safeLog('error', `[${new Date().toISOString()}] MCP Server starting...`);
 
   try {
     // Initialize workflow state
     workflowState = new WorkflowState();
-    console.error(`[${new Date().toISOString()}] Loading workflow state...`);
-    await workflowState.load();
-    console.error(`[${new Date().toISOString()}] Workflow state loaded.`);
-
-    console.error(`[${new Date().toISOString()}] Ensuring primary file...`);
-    await workflowState.ensurePrimaryFile();
-    console.error(`[${new Date().toISOString()}] Workflow state initialization complete.`);
+    // 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.`);
   } catch (error) {
-    console.error(`[${new Date().toISOString()}] Warning: Failed to initialize workflow state:`, error.message);
+    safeLog('error', `[${new Date().toISOString()}] Warning: Failed to initialize workflow state:`, error.message);
     // Continue anyway - workflow state is optional for MCP to function
     workflowState = new WorkflowState();
   }
 
   const transport = new StdioServerTransport();
-  console.error(`[${new Date().toISOString()}] Connecting transport...`);
+  // Cover SDK-generated protocol errors as well as tool-handler responses.
+  const send = transport.send.bind(transport);
+  transport.send = message => send(securityOutputFilter(message));
+  safeLog('error', `[${new Date().toISOString()}] Connecting transport...`);
   await server.connect(transport);
   const duration = Date.now() - startTime;
-  console.error(`[${new Date().toISOString()}] Dev Workflow MCP Server running on stdio (startup took ${duration}ms)`);
+  safeLog('error', `[${new Date().toISOString()}] Dev Workflow MCP Server running on stdio (startup took ${duration}ms)`);
 }
 
 // --- Lightweight CLI: dev-workflow-mcp call <toolName> [--args '<json>'] ---
@@ -207,7 +216,7 @@ async function cliMain(argv) {
   if (subcommand !== "call") return false;
 
   if (!toolName || typeof toolName !== "string" || toolName.trim() === "") {
-    console.error("Usage: dev-workflow-mcp call <toolName> [--args '<json>']");
+    safeLog('error', "Usage: dev-workflow-mcp call <toolName> [--args '<json>']");
     process.exit(2);
   }
 
@@ -243,11 +252,11 @@ async function cliMain(argv) {
     });
 
     const text = response?.content?.[0]?.text || "";
-    console.log(text);
-    const isError = /^\s*[⚠️❌]/u.test(text);
+    console.log(sanitize(text));
+    const isError = response?.isError === true || /^\s*[⚠️❌]/u.test(text);
     process.exit(isError ? 1 : 0);
   } catch (error) {
-    console.error("CLI error:", error.message || String(error));
+    safeLog('error', "CLI error:", error.message || String(error));
     process.exit(1);
   }
 }
@@ -259,7 +268,7 @@ if (isDirectRun) {
     cliMain(process.argv);
   } else {
     main().catch((error) => {
-      console.error("Server error:", error);
+      safeLog('error', "Server error:", error);
       process.exit(1);
     });
   }

package/install.js

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import { safeLog } from './security/sanitizer.js';
 
 /**
  * Installation script for dev-workflow MCP server
@@ -21,7 +22,7 @@ async function install() {
     // If INIT_CWD points inside node_modules, this script is being executed
     // while installing the package itself. In that case, skip creating a state file.
     if (projectRoot.includes(`node_modules${path.sep}`)) {
-      console.log('ℹ️ Skipping workflow state creation inside node_modules.');
+      safeLog('info', 'ℹ️ Skipping workflow state creation inside node_modules.');
       return;
     }
 
@@ -34,7 +35,7 @@ async function install() {
     // Check if state file already exists
     try {
       await fs.access(stateFile);
-      console.log(`✓ Workflow state file already exists at ${stateFile}`);
+      safeLog('info', `✓ Workflow state file already exists at ${stateFile}`);
       return;
     } catch {
       // File doesn't exist, create it
@@ -62,10 +63,10 @@ async function install() {
     };
 
     await fs.writeFile(stateFile, JSON.stringify(initialState, null, 2));
-    console.log(`✓ Created workflow state file at ${stateFile}`);
-    console.log(`✓ Each project now has its own isolated workflow history`);
+    safeLog('info', `✓ Created workflow state file at ${stateFile}`);
+    safeLog('info', `✓ Each project now has its own isolated workflow history`);
   } catch (error) {
-    console.error('✗ Installation failed:', error.message);
+    safeLog('error', '✗ Installation failed:', error.message);
     process.exit(1);
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@programinglive/dev-workflow-mcp-server",
-  "version": "1.12.1",
+  "version": "1.13.0",
   "description": "MCP server to enforce development workflow discipline",
   "homepage": "https://devworkflow.programinglive.com/",
   "mcpName": "io.github.programinglive/dev-workflow-mcp-server",
@@ -22,6 +22,9 @@
     "local": "node index.js",
     "setup": "node scripts/setup-stack.js",
     "test": "node --no-deprecation --test",
+    "test:security": "node --no-deprecation --test tests/security*.test.js",
+    "security:audit": "node index.js call security_audit",
+    "lint": "node scripts/lint.mjs",
     "check": "node --check index.js",
     "prepare": "node scripts/install-husky.js",
     "postinstall": "node install.js",

package/release-wrapper.js

@@ -1,4 +1,6 @@
 #!/usr/bin/env node
+import { safeLog } from './security/sanitizer.js';
+import { assertSafeKnowledge } from './security/policy.js';
 
 import { spawn } from 'node:child_process';
 import fs from 'node:fs/promises';
@@ -74,7 +76,7 @@ async function main() {
   const additionalArgs = process.argv.slice(3).filter((arg) => arg !== '--force');
 
   if (!RELEASE_TYPES.has(releaseTypeArg)) {
-    console.error(
+    safeLog('error',
       '❌ Release guard: expected release type argument (major | minor | patch). Example: npm run release:patch'
     );
     process.exit(1);
@@ -83,14 +85,14 @@ async function main() {
   const repoRoot = process.cwd();
   const projectRootCandidate = process.env.INIT_CWD || repoRoot;
   if (projectRootCandidate.includes(`node_modules${path.sep}`)) {
-    console.error('❌ Release guard: refusing to run inside node_modules.');
+    safeLog('error', '❌ Release guard: refusing to run inside node_modules.');
     process.exit(1);
   }
   const projectRoot = projectRootCandidate;
 
   const result = await loadWorkflowStateCandidates(projectRoot);
   if (!result) {
-    console.error(
+    safeLog('error',
       `❌ Release guard: cannot locate workflow state under ${path.join(projectRoot, '.state')}.
 Make sure the dev-workflow MCP is installed and you have started a task.`
     );
@@ -98,6 +100,12 @@ Make sure the dev-workflow MCP is installed and you have started a task.`
   }
 
   const { state, path: statePath } = result;
+  try {
+    assertSafeKnowledge(state);
+  } catch (error) {
+    safeLog('error', 'Release guard: unsafe legacy knowledge; remediate before releasing.', error);
+    process.exit(1);
+  }
 
   const errors = [];
   if (state.currentPhase !== 'release') {
@@ -116,20 +124,20 @@ Make sure the dev-workflow MCP is installed and you have started a task.`
   }
 
   if (errors.length && !forceFlag) {
-    console.error('❌ Release guard blocked the release:');
+    safeLog('error', '❌ Release guard blocked the release:');
     for (const message of errors) {
-      console.error(`  • ${message}`);
+      safeLog('error', `  • ${message}`);
     }
-    console.error("\nUse 'perform_release' through the dev-workflow MCP after completing the missing steps.");
-    console.error("Or use: npm run release:patch -- --force (to bypass guard)");
+    safeLog('error', "\nUse 'perform_release' through the dev-workflow MCP after completing the missing steps.");
+    safeLog('error', "Or use: npm run release:patch -- --force (to bypass guard)");
     process.exit(1);
   }
 
   if (forceFlag && errors.length) {
-    console.warn('⚠️ --force flag detected. Bypassing workflow guard.');
-    console.warn('Errors that were skipped:');
+    safeLog('warn', '⚠️ --force flag detected. Bypassing workflow guard.');
+    safeLog('warn', 'Errors that were skipped:');
     for (const message of errors) {
-      console.warn(`  • ${message}`);
+      safeLog('warn', `  • ${message}`);
     }
   }
 
@@ -138,15 +146,15 @@ Make sure the dev-workflow MCP is installed and you have started a task.`
   try {
     await fs.access(commiterReleaseScript);
   } catch {
-    console.error('❌ Release guard: @programinglive/commiter release script not found.');
-    console.error('   Ensure @programinglive/commiter is installed as a dev dependency.');
-    console.error('   Try: npm install --save-dev @programinglive/commiter');
+    safeLog('error', '❌ Release guard: @programinglive/commiter release script not found.');
+    safeLog('error', '   Ensure @programinglive/commiter is installed as a dev dependency.');
+    safeLog('error', '   Try: npm install --save-dev @programinglive/commiter');
     process.exit(1);
   }
 
   const runRelease = async () => {
     if (process.env.DEV_WORKFLOW_SKIP_RELEASE === '1') {
-      console.log('ℹ️ DEV_WORKFLOW_SKIP_RELEASE=1 detected. Skipping actual release command.');
+      safeLog('info', 'ℹ️ DEV_WORKFLOW_SKIP_RELEASE=1 detected. Skipping actual release command.');
       return 0;
     }
 
@@ -154,9 +162,13 @@ Make sure the dev-workflow MCP is installed and you have started a task.`
       const child = spawn(
         process.execPath,
         [commiterReleaseScript, releaseTypeArg, ...additionalArgs],
-        { stdio: 'inherit', cwd: repoRoot }
+        { stdio: ['ignore','pipe','pipe'], cwd: repoRoot }
       );
 
+      let output='';
+      child.stdout.on('data',chunk=>{if(output.length<1024*1024)output+=chunk.toString();});
+      child.stderr.on('data',chunk=>{if(output.length<1024*1024)output+=chunk.toString();});
+      child.on('close',()=>safeLog('info',output));
       child.on('error', (error) => reject(error));
       child.on('close', (code) => resolve(code));
     });
@@ -165,11 +177,11 @@ Make sure the dev-workflow MCP is installed and you have started a task.`
   try {
     const exitCode = await runRelease();
     if (exitCode !== 0) {
-      console.error(`❌ Release command exited with code ${exitCode}.`);
+      safeLog('error', `❌ Release command exited with code ${exitCode}.`);
       process.exit(exitCode);
     }
   } catch (error) {
-    console.error(`❌ Failed to run release command: ${error.message}`);
+    safeLog('error', `❌ Failed to run release command: ${error.message}`);
     process.exit(1);
   }
 
@@ -180,13 +192,14 @@ Make sure the dev-workflow MCP is installed and you have started a task.`
   state.currentPhase = 'ready_to_complete';
 
   try {
+    assertSafeKnowledge(state);
     await fs.writeFile(statePath, JSON.stringify(state, null, 2));
   } catch (error) {
-    console.error(`❌ Release guard: failed to update workflow state. ${error.message}`);
+    safeLog('error', `❌ Release guard: failed to update workflow state. ${error.message}`);
     process.exit(1);
   }
 
-  console.log('✅ Release recorded in workflow state. You can now run complete_task.');
+  safeLog('info', '✅ Release recorded in workflow state. You can now run complete_task.');
 }
 
 main();

package/scripts/check-review-guard.mjs

@@ -0,0 +1,33 @@
+// Bukti bahwa penjaga review-ganda akan menyala pada data Factory sungguhan.
+// Read-only: hanya membaca workspace, tidak pernah POST /api/work.
+import { readFactoryConfig, readWorkspace, findBlockingReviewEvent } from "../factory-client.js";
+
+const TASKS = {
+  "5127f86d": "5127f86d-e32f-4b00-991c-d817c01e2774",
+  "db4468aa": "db4468aa-0000-4000-8000-000000000000",
+  "f57f017b": "f57f017b-915c-4a91-a25d-ecb3a7050260",
+  "6a833f7d": "6a833f7d-4ea6-4e30-9c9b-3d93f4e2c428",
+};
+
+const config = readFactoryConfig();
+if (!config) {
+  console.error("Factory belum dikonfigurasi (FACTORY_URL/FACTORY_TOKEN atau email+password).");
+  process.exit(1);
+}
+
+const workspace = await readWorkspace(config);
+console.log(`workspace: ${(workspace.tasks || []).length} task, ${(workspace.events || []).length} event\n`);
+
+for (const [short, id] of Object.entries(TASKS)) {
+  const task = (workspace.tasks || []).find((t) => t.id === id);
+  if (!task) {
+    console.log(`${short}: task tidak ditemukan (id contoh)`);
+    continue;
+  }
+  const prior = findBlockingReviewEvent(workspace.events, id);
+  const aktif = task.work?.state === "active";
+  console.log(`${short}  status=${task.status.padEnd(8)} sesi=${String(task.work?.state).padEnd(8)}`);
+  console.log(`   penjaga review: ${prior ? `MENOLAK (${prior.kind} @ ${prior.createdAt})` : "lolos"}`);
+  if (prior && aktif) console.log("   -> akan ditolak sebelum POST /api/work");
+  console.log();
+}