@programinglive/dev-workflow-mcp-server 1.0.11 → 1.1.2

package/CHANGELOG.md

@@ -2,6 +2,34 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+### [1.1.2](https://github.com/programinglive/dev-workflow-mcp-server/compare/v1.1.1...v1.1.2) (2025-10-25)
+
+### [1.1.1](https://github.com/programinglive/dev-workflow-mcp-server/compare/v1.1.0...v1.1.1) (2025-10-25)
+
+
+### ✨ Features
+
+* add force_complete_task tool ([f731a7d](https://github.com/programinglive/dev-workflow-mcp-server/commit/f731a7d2e48295963b8573d4a2abd3ebd42ba5ab))
+
+## [1.1.0](https://github.com/programinglive/dev-workflow-mcp-server/compare/v1.0.11...v1.1.0) (2025-10-25)
+
+
+### 📝 Documentation
+
+* clarify commit and push step ([c741f61](https://github.com/programinglive/dev-workflow-mcp-server/commit/c741f618813479c5df2bcca94c3dffc8881e97c8))
+
+
+### 🐛 Bug Fixes
+
+* allow commit_and_push on clean tree ([a831974](https://github.com/programinglive/dev-workflow-mcp-server/commit/a831974f66313ebe8752d416752076df63902bea))
+* auto-detect commit in perform_release when tree is clean ([0db7038](https://github.com/programinglive/dev-workflow-mcp-server/commit/0db7038148f68963f53e52a5f73623dea7ad3462))
+
+
+### ✨ Features
+
+* check staged changes when resetting workflow to commit phase ([05d02fd](https://github.com/programinglive/dev-workflow-mcp-server/commit/05d02fd7ec6177af3fb1fd86ec093e1e37b56cbd))
+* continue_workflow auto-executes next step in commit phase ([a5b49ed](https://github.com/programinglive/dev-workflow-mcp-server/commit/a5b49edaae7cb51ea3aa49d9b1b64587843441ce))
+
 ### [1.0.11](https://github.com/programinglive/dev-workflow-mcp-server/compare/v1.0.10...v1.0.11) (2025-10-25)
 
 

package/README.md

@@ -11,8 +11,8 @@ This MCP server guides you through a disciplined development workflow:
 3. **Create Tests** - Always test your changes
 4. **Run Tests** - Tests must pass (GREEN)
 5. **Document** - Update documentation
-6. **Commit & Push** - Let the server drive the git commands once verification passes
-7. **Release** - Record the release details before closing out the task
+6. **Commit & Push** - Let the server stage, commit, **and push** your changes once verification passes (if you make new edits afterward, the workflow moves back to this step automatically)
+7. **Release** - After the push succeeds, record the release details before closing out the task
 
 ## 🚀 Installation
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@programinglive/dev-workflow-mcp-server",
-  "version": "1.0.11",
+  "version": "1.1.2",
   "description": "MCP server to enforce development workflow discipline",
   "type": "module",
   "main": "index.js",

package/tests/handlers.test.js

@@ -58,6 +58,7 @@ test("commit_and_push commits changes and pushes", async () => {
 
     const git = {
       hasWorkingChanges: async () => true,
+      hasStagedChanges: async () => false,
       hasTestChanges: async () => true,
       getStagedChanges: async () => [{ status: "M", path: "src/index.js" }],
       getCurrentBranch: async () => "main",
@@ -95,10 +96,85 @@ test("commit_and_push commits changes and pushes", async () => {
   });
 });
 
+test("force_complete_task records entry and resets state", async () => {
+  await withWorkflowState(async (workflowState) => {
+    workflowState.state.taskDescription = "Improve caching";
+    workflowState.state.taskType = "feature";
+    workflowState.state.lastCommitMessage = "chore: wip";
+    workflowState.state.currentPhase = "release";
+    await workflowState.save();
+
+    const response = await handleToolCall({
+      request: createRequest("force_complete_task", {
+        commitMessage: "chore: force finish",
+        reason: "Deadline hit",
+      }),
+      normalizeRequestArgs,
+      workflowState,
+      exec: async () => ({ stdout: "" }),
+      git: {},
+      utils,
+    });
+
+    assert.ok(response.content[0].text.includes("Task force-completed."));
+    assert.equal(workflowState.state.currentPhase, "idle");
+    assert.equal(workflowState.state.history.length, 1);
+    assert.equal(workflowState.state.history[0].commitMessage, "chore: force finish");
+    assert.equal(workflowState.state.history[0].forced, true);
+    assert.equal(workflowState.state.history[0].forceReason, "Deadline hit");
+  });
+});
+
+test("perform_release blocks when new changes detected", async () => {
+  await withWorkflowState(async (workflowState) => {
+    workflowState.state.currentPhase = "release";
+    workflowState.state.commitAndPushCompleted = true;
+    workflowState.state.readyCheckCompleted = true;
+    await workflowState.save();
+
+    const commands = [];
+    const execStub = async (command) => {
+      commands.push(command);
+      if (command === "git status --porcelain") {
+        return { stdout: "?? new-file.js" };
+      }
+
+      return { stdout: "" };
+    };
+
+    const git = {
+      hasWorkingChanges: async () => true,
+      hasStagedChanges: async () => false,
+      hasTestChanges: async () => true,
+      getStagedChanges: async () => [],
+      getCurrentBranch: async () => "main",
+      getLastCommitMessage: async () => "fix: adjust layout",
+      workingTreeSummary: () => ({ hasChanges: true, lines: ["?? new-file.js"] }),
+    };
+
+    const response = await handleToolCall({
+      request: createRequest("perform_release", { command: "patch" }),
+      normalizeRequestArgs,
+      workflowState,
+      exec: execStub,
+      git,
+      utils,
+    });
+
+    assert.ok(
+      response.content[0].text.includes("run 'commit_and_push' again"),
+      "response should instruct to recommit"
+    );
+    assert.equal(workflowState.state.currentPhase, "commit");
+    assert.equal(workflowState.state.commitAndPushCompleted, false);
+  });
+});
+
 test("continue_workflow warns when workflow is idle", async () => {
   await withWorkflowState(async (workflowState) => {
     const git = {
       hasWorkingChanges: async () => false,
+      hasStagedChanges: async () => false,
       hasTestChanges: async () => false,
       getStagedChanges: async () => [],
       getCurrentBranch: async () => "main",
@@ -122,6 +198,87 @@ test("continue_workflow warns when workflow is idle", async () => {
   });
 });
 
+test("continue_workflow resets to commit when new changes detected", async () => {
+  await withWorkflowState(async (workflowState) => {
+    workflowState.state.currentPhase = "release";
+    workflowState.state.commitAndPushCompleted = true;
+    workflowState.state.readyCheckCompleted = true;
+    await workflowState.save();
+
+    const git = {
+      hasWorkingChanges: async () => true,
+      hasStagedChanges: async () => false,
+      hasTestChanges: async () => true,
+      getStagedChanges: async () => [],
+      getCurrentBranch: async () => "main",
+      getLastCommitMessage: async () => "fix: adjust layout",
+      workingTreeSummary: () => ({ hasChanges: false, lines: [] }),
+    };
+
+    const response = await handleToolCall({
+      request: createRequest("continue_workflow", {}),
+      normalizeRequestArgs,
+      workflowState,
+      exec: async () => ({ stdout: "" }),
+      git,
+      utils,
+    });
+
+    assert.ok(
+      response.content[0].text.includes("Workflow moved back to the commit phase"),
+      "response should warn that workflow reset to commit"
+    );
+    assert.equal(workflowState.state.currentPhase, "commit");
+    assert.equal(workflowState.state.commitAndPushCompleted, false);
+  });
+});
+
+test("commit_and_push recognizes already committed work", async () => {
+  await withWorkflowState(async (workflowState) => {
+    workflowState.state.readyToCommit = true;
+    workflowState.state.readyCheckCompleted = true;
+    workflowState.state.testsSkipped = false;
+    workflowState.state.testsCreated = true;
+    workflowState.state.testsPassed = true;
+    workflowState.state.currentPhase = "commit";
+    await workflowState.save();
+
+    const commands = [];
+    const execStub = async (command) => {
+      commands.push(command);
+      return { stdout: "" };
+    };
+
+    const git = {
+      hasWorkingChanges: async () => false,
+      hasStagedChanges: async () => false,
+      hasTestChanges: async () => true,
+      getStagedChanges: async () => [],
+      getCurrentBranch: async () => "main",
+      getLastCommitMessage: async () => "fix: previous work",
+      workingTreeSummary: () => ({ hasChanges: false, lines: [] }),
+    };
+
+    const response = await handleToolCall({
+      request: createRequest("commit_and_push", { commitMessage: "" }),
+      normalizeRequestArgs,
+      workflowState,
+      exec: execStub,
+      git,
+      utils,
+    });
+
+    assert.equal(commands.length, 0, "no git commands should run when work is already committed");
+    assert.ok(
+      response.content[0].text.includes("No changes detected"),
+      "response should note that no changes were detected"
+    );
+    assert.equal(workflowState.state.commitAndPushCompleted, true);
+    assert.equal(workflowState.state.lastCommitMessage, "fix: previous work");
+    assert.equal(workflowState.state.currentPhase, "release");
+  });
+});
+
 test("perform_release runs release command before pushing with tags", async () => {
   await withWorkflowState(async (workflowState) => {
     workflowState.state.currentPhase = "release";
@@ -143,6 +300,7 @@ test("perform_release runs release command before pushing with tags", async () =
 
     const git = {
       hasWorkingChanges: async () => false,
+      hasStagedChanges: async () => false,
       hasTestChanges: async () => true,
       getStagedChanges: async () => [],
       getCurrentBranch: async () => "main",
@@ -186,3 +344,146 @@ test("perform_release runs release command before pushing with tags", async () =
     );
   });
 });
+
+test("perform_release accepts shorthand patch command", async () => {
+  await withWorkflowState(async (workflowState) => {
+    workflowState.state.currentPhase = "release";
+    workflowState.state.commitAndPushCompleted = true;
+    workflowState.state.readyCheckCompleted = true;
+    workflowState.state.lastCommitMessage = "fix: adjust labels";
+    await workflowState.save();
+
+    const commands = [];
+    const execStub = async (command) => {
+      commands.push(command);
+      if (command === "git status --porcelain") {
+        return { stdout: "" };
+      }
+
+      return { stdout: "" };
+    };
+
+    const git = {
+      hasWorkingChanges: async () => false,
+      hasStagedChanges: async () => false,
+      hasTestChanges: async () => true,
+      getStagedChanges: async () => [],
+      getCurrentBranch: async () => "main",
+      getLastCommitMessage: async () => "fix: adjust labels",
+      workingTreeSummary: () => ({ hasChanges: false, lines: [] }),
+    };
+
+    await handleToolCall({
+      request: createRequest("perform_release", { command: "patch" }),
+      normalizeRequestArgs,
+      workflowState,
+      exec: execStub,
+      git,
+      utils,
+    });
+
+    const releaseCommand = commands.find((command) => command.startsWith("npm run release:patch"));
+    assert.ok(releaseCommand, "shorthand patch command should map to release:patch script");
+    const pushCommand = commands.find((command) => command.startsWith("git push --follow-tags"));
+    assert.ok(pushCommand, "git push with tags should run after shorthand release");
+  });
+});
+
+test("perform_release respects explicit releaseType option", async () => {
+  await withWorkflowState(async (workflowState) => {
+    workflowState.state.currentPhase = "release";
+    workflowState.state.commitAndPushCompleted = true;
+    workflowState.state.readyCheckCompleted = true;
+    await workflowState.save();
+
+    const commands = [];
+    const execStub = async (command) => {
+      commands.push(command);
+      if (command === "git status --porcelain") {
+        return { stdout: "" };
+      }
+
+      return { stdout: "" };
+    };
+
+    const git = {
+      hasWorkingChanges: async () => false,
+      hasStagedChanges: async () => false,
+      hasTestChanges: async () => true,
+      getStagedChanges: async () => [],
+      getCurrentBranch: async () => "main",
+      getLastCommitMessage: async () => "feat: import improvements",
+      workingTreeSummary: () => ({ hasChanges: false, lines: [] }),
+    };
+
+    await handleToolCall({
+      request: createRequest("perform_release", {
+        command: "npm run release",
+        releaseType: "minor",
+      }),
+      normalizeRequestArgs,
+      workflowState,
+      exec: execStub,
+      git,
+      utils,
+    });
+
+    const releaseCommand = commands.find((command) => command.startsWith("npm run release"));
+    assert.ok(releaseCommand, "release command should run");
+    assert.ok(
+      releaseCommand.includes("-- --release-as minor"),
+      "release command should append provided releaseType"
+    );
+  });
+});
+
+test("perform_release auto-detects commit when tree is clean", async () => {
+  await withWorkflowState(async (workflowState) => {
+    workflowState.state.currentPhase = "release";
+    workflowState.state.commitAndPushCompleted = false;
+    workflowState.state.readyCheckCompleted = true;
+    workflowState.state.lastPushBranch = "";
+    workflowState.state.lastCommitMessage = "";
+    await workflowState.save();
+
+    const commands = [];
+    const execStub = async (command) => {
+      commands.push(command);
+      if (command === "git status --porcelain") {
+        return { stdout: "" };
+      }
+
+      return { stdout: "" };
+    };
+
+    const git = {
+      hasWorkingChanges: async () => false,
+      hasStagedChanges: async () => false,
+      hasTestChanges: async () => true,
+      getStagedChanges: async () => [],
+      getCurrentBranch: async () => "main",
+      getLastCommitMessage: async () => "chore: already pushed",
+      workingTreeSummary: () => ({ hasChanges: false, lines: [] }),
+    };
+
+    const response = await handleToolCall({
+      request: createRequest("perform_release", { command: "npm run release" }),
+      normalizeRequestArgs,
+      workflowState,
+      exec: execStub,
+      git,
+      utils,
+    });
+
+    const pushCommand = commands.find((command) => command.startsWith("git push --follow-tags"));
+    assert.ok(pushCommand, "git push with tags should still run");
+    assert.equal(workflowState.state.commitAndPushCompleted, true);
+    assert.equal(workflowState.state.lastCommitMessage, "chore: already pushed");
+    assert.equal(workflowState.state.lastPushBranch, "main");
+    assert.equal(workflowState.state.currentPhase, "ready_to_complete");
+    assert.ok(
+      response.content[0].text.includes("Detected clean working tree"),
+      "response should mention auto-detected commit"
+    );
+  });
+});

package/tools/definitions.js

@@ -163,6 +163,24 @@ export function getToolList() {
         required: ["commitMessage"],
       },
     },
+    {
+      name: "force_complete_task",
+      description:
+        "Force completion of the current task even if workflow steps are incomplete. Records history entry and resets the workflow.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          commitMessage: {
+            type: "string",
+            description: "Commit message or summary to record (optional)",
+          },
+          reason: {
+            type: "string",
+            description: "Why the task was force completed",
+          },
+        },
+      },
+    },
     {
       name: "drop_task",
       description:

package/tools/handlers.js

@@ -7,6 +7,27 @@ const textResponse = (text) => ({
   ],
 });
 
+async function resetToCommitIfWorkingChanges(workflowState, git) {
+  if (!workflowState.state.commitAndPushCompleted) {
+    return false;
+  }
+
+  const hasWorkingChanges = await git.hasWorkingChanges();
+  const hasStagedChanges = await git.hasStagedChanges();
+  
+  if (!hasWorkingChanges && !hasStagedChanges) {
+    return false;
+  }
+
+  workflowState.state.commitAndPushCompleted = false;
+  workflowState.state.released = false;
+  workflowState.state.currentPhase = "commit";
+  workflowState.state.releaseCommand = "";
+  workflowState.state.releaseNotes = "";
+  await workflowState.save();
+  return true;
+}
+
 function formatChecklist(checks) {
   return checks.map((c) => `${c.done ? "✅" : "❌"} ${c.name}`).join("\n");
 }
@@ -68,17 +89,33 @@ function getContinueGuidance(status) {
   }
 }
 
-async function handleContinueWorkflow(workflowState) {
+async function handleContinueWorkflow(workflowState, context) {
   const status = workflowState.state;
 
   if (!status || status.currentPhase === "idle") {
     return textResponse("⚠️ No active workflow. Use 'start_task' to kick off a new task before continuing.");
   }
 
+  if (await resetToCommitIfWorkingChanges(workflowState, context.git)) {
+    return textResponse(
+      "⚠️ Detected new changes after the last commit. Workflow moved back to the commit phase. Run 'commit_and_push' to capture the latest updates before continuing."
+    );
+  }
+
   if (status.currentPhase === "ready") {
     return handleReadyCheck(workflowState);
   }
 
+  if (status.currentPhase === "commit") {
+    return handleCommitAndPush({}, context);
+  }
+
+  if (status.currentPhase === "release") {
+    return textResponse(
+      "⚠️ Release phase requires explicit command. Run 'perform_release' with your release command (e.g., 'npm run release')."
+    );
+  }
+
   const sections = [
     `📊 Current Phase: ${status.currentPhase}`,
     `📝 Task: ${status.taskDescription || "(none)"}`,
@@ -334,9 +371,26 @@ async function handleCommitAndPush(args, context) {
   const providedCommitMessage =
     typeof args.commitMessage === "string" ? args.commitMessage.trim() : "";
 
-  if (!(await git.hasWorkingChanges())) {
+  const requestedBranch = typeof args.branch === "string" ? args.branch.trim() : "";
+  const currentBranch = await git.getCurrentBranch();
+  const branchForPush = requestedBranch || currentBranch || "";
+
+  const hasWorkingChanges = await git.hasWorkingChanges();
+
+  if (!hasWorkingChanges) {
+    const lastCommitMessage = await git.getLastCommitMessage();
+    const effectiveCommitMessage = lastCommitMessage || providedCommitMessage;
+
+    workflowState.state.commitAndPushCompleted = true;
+    workflowState.state.lastCommitMessage = effectiveCommitMessage || "";
+    workflowState.state.lastPushBranch = branchForPush;
+    workflowState.state.currentPhase = workflowState.state.released ? "ready_to_complete" : "release";
+    await workflowState.save();
+
     return textResponse(
-      "⚠️ No changes detected. Make sure you have modifications to commit before running 'commit_and_push'."
+      `ℹ️ No changes detected. Assuming commit and push already completed.\nLast commit: ${
+        effectiveCommitMessage || "(unavailable)"
+      }\n\nNext: Run 'perform_release' to handle the release and push tags.`
     );
   }
 
@@ -383,10 +437,6 @@ async function handleCommitAndPush(args, context) {
     return textResponse(`❌ git commit failed:\n\n${output}`);
   }
 
-  const requestedBranch = typeof args.branch === "string" ? args.branch.trim() : "";
-  const currentBranch = await git.getCurrentBranch();
-  const branchForPush = requestedBranch || currentBranch || "";
-
   try {
     const pushCommand = branchForPush
       ? `git push origin ${utils.shellEscape(branchForPush)}`
@@ -418,9 +468,9 @@ async function handlePerformRelease(args, context) {
     return textResponse("⚠️ Please start a task first using 'start_task'!");
   }
 
-  if (!workflowState.state.commitAndPushCompleted) {
+  if (await resetToCommitIfWorkingChanges(workflowState, git)) {
     return textResponse(
-      "⚠️ Please run 'commit_and_push' after the ready check before recording a release!"
+      "⚠️ Detected new changes after the last commit. Please run 'commit_and_push' again before recording a release."
     );
   }
 
@@ -430,7 +480,67 @@ async function handlePerformRelease(args, context) {
     );
   }
 
-  const releaseCommand = typeof args.command === "string" ? args.command.trim() : "";
+  let autoDetectedCommit = false;
+
+  if (!workflowState.state.commitAndPushCompleted) {
+    const hasWorkingChanges = await git.hasWorkingChanges();
+
+    if (hasWorkingChanges) {
+      return textResponse(
+        "⚠️ Please run 'commit_and_push' after the ready check before recording a release!"
+      );
+    }
+
+    const lastCommitMessage = await git.getLastCommitMessage();
+    const currentBranch = await git.getCurrentBranch();
+
+    workflowState.state.commitAndPushCompleted = true;
+    workflowState.state.lastCommitMessage =
+      lastCommitMessage || workflowState.state.lastCommitMessage || "";
+    workflowState.state.lastPushBranch = currentBranch || workflowState.state.lastPushBranch || "";
+    workflowState.state.currentPhase = "release";
+    autoDetectedCommit = true;
+    await workflowState.save();
+  }
+
+  const rawReleaseCommand = typeof args.command === "string" ? args.command.trim() : "";
+  const releaseTypeArg =
+    typeof args.releaseType === "string" ? args.releaseType.trim().toLowerCase() : "";
+  const presetArg = typeof args.preset === "string" ? args.preset.trim().toLowerCase() : "";
+  const recognizedTypes = new Set(["major", "minor", "patch"]);
+
+  const tokens = rawReleaseCommand
+    .toLowerCase()
+    .split(/\s+/)
+    .map((token) => token.trim())
+    .filter(Boolean);
+
+  let releaseType = "";
+  if (recognizedTypes.has(releaseTypeArg)) {
+    releaseType = releaseTypeArg;
+  } else if (recognizedTypes.has(presetArg)) {
+    releaseType = presetArg;
+  } else if (tokens.length > 0) {
+    const possibleType = tokens[tokens.length - 1];
+    if (recognizedTypes.has(possibleType)) {
+      releaseType = possibleType;
+    }
+  }
+
+  let releaseCommand = rawReleaseCommand;
+  if (releaseCommand && recognizedTypes.has(releaseCommand.toLowerCase())) {
+    releaseType = releaseCommand.toLowerCase();
+    releaseCommand = "";
+  }
+
+  const scriptTypeMatch = /release:(major|minor|patch)/i.exec(releaseCommand);
+  if (scriptTypeMatch) {
+    releaseType = scriptTypeMatch[1].toLowerCase();
+  }
+
+  if (!releaseCommand && releaseType) {
+    releaseCommand = `npm run release:${releaseType}`;
+  }
 
   if (!releaseCommand) {
     return textResponse("⚠️ Please provide a non-empty 'command' when using 'perform_release'.");
@@ -460,13 +570,16 @@ async function handlePerformRelease(args, context) {
   }
 
   const lastCommitMessage = await git.getLastCommitMessage();
-  const releaseType = utils.determineReleaseTypeFromCommit(
-    lastCommitMessage || workflowState.state.lastCommitMessage
-  );
+  if (!releaseType) {
+    releaseType = utils.determineReleaseTypeFromCommit(
+      lastCommitMessage || workflowState.state.lastCommitMessage
+    );
+  }
 
-  const finalCommand = releaseCommand.includes("--release-as")
-    ? releaseCommand
-    : `${releaseCommand} -- --release-as ${releaseType}`;
+  const finalCommand =
+    releaseCommand.includes("--release-as") || /release:(major|minor|patch)/i.test(releaseCommand)
+      ? releaseCommand
+      : `${releaseCommand} -- --release-as ${releaseType}`;
 
   try {
     await exec(finalCommand);
@@ -497,10 +610,16 @@ async function handlePerformRelease(args, context) {
 
   const message = summarizeHistory(workflowState.state.history, args.limit || 10);
   if (!message) {
-    return textResponse("📜 No workflow history yet.");
+    const autoNote = autoDetectedCommit
+      ? "\n\nℹ️ Detected clean working tree and treated commit/push as already completed."
+      : "";
+    return textResponse(`📜 No workflow history yet.${autoNote}`);
   }
 
-  return textResponse(message);
+  const autoNote = autoDetectedCommit
+    ? "\n\nℹ️ Detected clean working tree and treated commit/push as already completed."
+    : "";
+  return textResponse(`${message}${autoNote}`);
 }
 
 async function handleCompleteTask(args, workflowState) {
@@ -519,6 +638,32 @@ async function handleCompleteTask(args, workflowState) {
   );
 }
 
+async function handleForceCompleteTask(args, workflowState) {
+  const commitMessageArg =
+    typeof args.commitMessage === "string" ? args.commitMessage.trim() : "";
+  const reason = typeof args.reason === "string" ? args.reason.trim() : "";
+
+  const commitMessage =
+    commitMessageArg || workflowState.state.lastCommitMessage || "(no commit recorded)";
+
+  workflowState.addToHistory({
+    taskDescription: workflowState.state.taskDescription,
+    taskType: workflowState.state.taskType,
+    commitMessage,
+    forced: true,
+    forceReason: reason,
+  });
+
+  workflowState.reset();
+  await workflowState.save();
+
+  const reasonText = reason ? reason : "(none provided)";
+
+  return textResponse(
+    `⚠️ Task force-completed.\n\nRecorded commit message: ${commitMessage}\nReason: ${reasonText}\nWorkflow state reset. Start a new task when ready.`
+  );
+}
+
 async function handleDropTask(args, workflowState) {
   workflowState.addToHistory({
     taskDescription: workflowState.state.taskDescription,
@@ -600,6 +745,8 @@ export async function handleToolCall({
         return handlePerformRelease(args, { workflowState, exec, git, utils });
       case "complete_task":
         return handleCompleteTask(args, workflowState);
+      case "force_complete_task":
+        return handleForceCompleteTask(args, workflowState);
       case "drop_task":
         return handleDropTask(args, workflowState);
       case "get_workflow_status":
@@ -607,7 +754,7 @@ export async function handleToolCall({
       case "view_history":
         return handleViewHistory(args, workflowState);
       case "continue_workflow":
-        return handleContinueWorkflow(workflowState);
+        return handleContinueWorkflow(workflowState, { workflowState, exec, git, utils });
       default:
         throw new Error(`Unknown tool: ${name}`);
     }