gsd-pi 2.4.0 → 2.5.0

package/README.md

@@ -252,17 +252,18 @@ Branch-per-slice with squash merge. Fully automated.
 
 ```
 main:
-  feat(M001/S03): auth and session management
+  docs(M001/S04): workflow documentation and examples
+  fix(M001/S03): bug fixes and doc corrections
   feat(M001/S02): API endpoints and middleware
   feat(M001/S01): data model and type system
 
-gsd/M001/S01 (preserved):
+gsd/M001/S01 (deleted after merge):
   feat(S01/T03): file writer with round-trip fidelity
   feat(S01/T02): markdown parser for plan files
   feat(S01/T01): core types and interfaces
 ```
 
-One commit per slice on main. Per-task history preserved on branches. Git bisect works. Individual slices are revertable.
+One commit per slice on main. Squash commits are the permanent record — branches are deleted after merge. Git bisect works. Individual slices are revertable.
 
 ### Verification
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gsd-pi",
-  "version": "2.4.0",
+  "version": "2.5.0",
   "description": "GSD — Get Shit Done coding agent",
   "license": "MIT",
   "repository": {
@@ -35,7 +35,7 @@
   "scripts": {
     "build": "tsc && npm run copy-themes",
     "copy-themes": "node -e \"const{mkdirSync,cpSync}=require('fs');const{resolve}=require('path');const src=resolve(__dirname,'node_modules/@mariozechner/pi-coding-agent/dist/modes/interactive/theme');mkdirSync('pkg/dist/modes/interactive/theme',{recursive:true});cpSync(src,'pkg/dist/modes/interactive/theme',{recursive:true})\"",
-    "test": "node --import ./src/resources/extensions/gsd/tests/resolve-ts.mjs --experimental-strip-types --test 'src/resources/extensions/gsd/tests/*.test.ts' 'src/resources/extensions/gsd/tests/*.test.mjs' 'src/tests/*.test.ts'",
+    "test": "node --import ./src/resources/extensions/gsd/tests/resolve-ts.mjs --experimental-strip-types --test src/resources/extensions/gsd/tests/*.test.ts src/resources/extensions/gsd/tests/*.test.mjs src/tests/*.test.ts",
     "dev": "tsc --watch",
     "postinstall": "node scripts/postinstall.js",
     "pi:install-global": "node scripts/install-pi-global.js",

package/src/resources/GSD-WORKFLOW.md

@@ -548,7 +548,7 @@ If files disagree, **pause and surface to the user**:
 1. **Slice starts** → create branch `gsd/M001/S01` from main
 2. **Per-task commits** on the branch — atomic, descriptive, bisectable
 3. **Slice completes** → squash merge to main as one clean commit
-4. **Branch kept** — not deleted, available for per-task history
+4. **Branch deleted** — squash commit on main is the permanent record
 
 ### What Main Looks Like
 
@@ -566,21 +566,21 @@ One commit per slice. Individually revertable. Reads like a changelog.
 gsd/M001/S01:
   test(S01): round-trip tests passing
   feat(S01/T03): file writer with round-trip fidelity
-  checkpoint(S01/T03): pre-task
+  chore(S01/T03): auto-commit after task
   feat(S01/T02): markdown parser for plan files
-  checkpoint(S01/T02): pre-task
+  chore(S01/T02): auto-commit after task
   feat(S01/T01): core types and interfaces
-  checkpoint(S01/T01): pre-task
+  chore(S01/T01): auto-commit after task
 ```
 
 ### Commit Conventions
 
 | When | Format | Example |
 |------|--------|---------|
-| Before each task | `checkpoint(S01/T02): pre-task` | Safety net for `git reset` |
+| Auto-commit (dirty state) | `chore(S01/T02): auto-commit after task` | Automatic save of work in progress |
 | After task verified | `feat(S01/T02): <what was built>` | The real work |
 | Plan/docs committed | `docs(S01): add slice plan` | Bundled with first task |
-| Slice squash to main | `feat(M001/S01): <slice title>` | Clean one-liner on main |
+| Slice squash to main | `type(M001/S01): <slice title>` | Type inferred from title (`feat`, `fix`, `docs`, etc.) |
 
 Commit types: `feat`, `fix`, `test`, `refactor`, `docs`, `chore`
 
@@ -601,7 +601,7 @@ Tasks completed:
 
 | Problem | Fix |
 |---------|-----|
-| Bad task | `git reset --hard` to checkpoint on the branch |
+| Bad task | `git reset --hard HEAD~1` to previous commit on the branch |
 | Bad slice | `git revert <squash commit>` on main |
 | UAT failure after merge | Fix tasks on `gsd/M001/S01-fix` branch, squash as `fix(M001/S01): <fix>` |
 

package/src/resources/extensions/gsd/auto.ts

@@ -62,11 +62,12 @@ import {
   ensureSliceBranch,
   getCurrentBranch,
   getMainBranch,
-  getSliceBranchName,
   parseSliceBranch,
   switchToMain,
   mergeSliceToMain,
 } from "./worktree.ts";
+import { GitServiceImpl } from "./git-service.ts";
+import type { GitPreferences } from "./git-service.ts";
 import { truncateToWidth, visibleWidth } from "@mariozechner/pi-tui";
 import { makeUI, GLYPH, INDENT } from "../shared/ui.js";
 import { showNextAction } from "../shared/next-action-ui.js";
@@ -93,6 +94,18 @@ function persistCompletedKey(base: string, key: string): void {
   }
 }
 
+/** Remove a stale completed unit key from disk. */
+function removePersistedKey(base: string, key: string): void {
+  const file = completedKeysPath(base);
+  try {
+    if (existsSync(file)) {
+      let keys: string[] = JSON.parse(readFileSync(file, "utf-8"));
+      keys = keys.filter(k => k !== key);
+      writeFileSync(file, JSON.stringify(keys), "utf-8");
+    }
+  } catch { /* non-fatal */ }
+}
+
 /** Load all completed unit keys from disk into the in-memory set. */
 function loadPersistedKeys(base: string, target: Set<string>): void {
   const file = completedKeysPath(base);
@@ -112,6 +125,7 @@ let stepMode = false;
 let verbose = false;
 let cmdCtx: ExtensionCommandContext | null = null;
 let basePath = "";
+let gitService: GitServiceImpl | null = null;
 
 /** Track total dispatches per unit to detect stuck loops (catches A→B→A→B patterns) */
 const unitDispatchCount = new Map<string, number>();
@@ -376,6 +390,9 @@ export async function startAuto(
     } catch { /* nothing to commit */ }
   }
 
+  // Initialize GitServiceImpl — basePath is set and git repo confirmed
+  gitService = new GitServiceImpl(basePath, loadEffectiveGSDPreferences()?.preferences?.git ?? {});
+
   // Check for crash from previous session
   const crashLock = readCrashLock(base);
   if (crashLock) {
@@ -1190,15 +1207,27 @@ async function dispatchNextUnit(
   // Idempotency: skip units already completed in a prior session.
   const idempotencyKey = `${unitType}/${unitId}`;
   if (completedKeySet.has(idempotencyKey)) {
-    ctx.ui.notify(
-      `Skipping ${unitType} ${unitId} — already completed in a prior session. Advancing.`,
-      "info",
-    );
-    // Yield to the event loop before re-dispatching to avoid tight recursion
-    // when many units are already completed (e.g., after crash recovery).
-    await new Promise(r => setImmediate(r));
-    await dispatchNextUnit(ctx, pi);
-    return;
+    // Cross-validate: does the expected artifact actually exist?
+    const artifactExists = verifyExpectedArtifact(unitType, unitId, basePath);
+    if (artifactExists) {
+      ctx.ui.notify(
+        `Skipping ${unitType} ${unitId} — already completed in a prior session. Advancing.`,
+        "info",
+      );
+      // Yield to the event loop before re-dispatching to avoid tight recursion
+      // when many units are already completed (e.g., after crash recovery).
+      await new Promise(r => setImmediate(r));
+      await dispatchNextUnit(ctx, pi);
+      return;
+    } else {
+      // Stale completion record — artifact missing. Remove and re-run.
+      completedKeySet.delete(idempotencyKey);
+      removePersistedKey(basePath, idempotencyKey);
+      ctx.ui.notify(
+        `Re-running ${unitType} ${unitId} — marked complete but expected artifact missing.`,
+        "warning",
+      );
+    }
   }
 
   // Stuck detection — tracks total dispatches per unit (not just consecutive repeats).
@@ -1234,20 +1263,26 @@ async function dispatchNextUnit(
     snapshotUnitMetrics(ctx, currentUnit.type, currentUnit.id, currentUnit.startedAt, modelId);
     saveActivityLog(ctx, basePath, currentUnit.type, currentUnit.id);
 
-    // Persist completion to disk BEFORE updating memory — so a crash here is recoverable.
+    // Only mark the previous unit as completed if:
+    // 1. We're not about to re-dispatch the same unit (retry scenario)
+    // 2. The expected artifact actually exists on disk
     const closeoutKey = `${currentUnit.type}/${currentUnit.id}`;
-    persistCompletedKey(basePath, closeoutKey);
-    completedKeySet.add(closeoutKey);
-
-    completedUnits.push({
-      type: currentUnit.type,
-      id: currentUnit.id,
-      startedAt: currentUnit.startedAt,
-      finishedAt: Date.now(),
-    });
-    clearUnitRuntimeRecord(basePath, currentUnit.type, currentUnit.id);
-    unitDispatchCount.delete(`${currentUnit.type}/${currentUnit.id}`);
-    unitRecoveryCount.delete(`${currentUnit.type}/${currentUnit.id}`);
+    const incomingKey = `${unitType}/${unitId}`;
+    const artifactVerified = verifyExpectedArtifact(currentUnit.type, currentUnit.id, basePath);
+    if (closeoutKey !== incomingKey && artifactVerified) {
+      persistCompletedKey(basePath, closeoutKey);
+      completedKeySet.add(closeoutKey);
+
+      completedUnits.push({
+        type: currentUnit.type,
+        id: currentUnit.id,
+        startedAt: currentUnit.startedAt,
+        finishedAt: Date.now(),
+      });
+      clearUnitRuntimeRecord(basePath, currentUnit.type, currentUnit.id);
+      unitDispatchCount.delete(`${currentUnit.type}/${currentUnit.id}`);
+      unitRecoveryCount.delete(`${currentUnit.type}/${currentUnit.id}`);
+    }
   }
   currentUnit = { type: unitType, id: unitId, startedAt: Date.now() };
   writeUnitRuntimeRecord(basePath, unitType, unitId, currentUnit.startedAt, {
@@ -2587,6 +2622,15 @@ export function resolveExpectedArtifactPath(unitType: string, unitId: string, ba
       const dir = resolveSlicePath(base, mid, sid!);
       return dir ? join(dir, buildSliceFileName(sid!, "UAT-RESULT")) : null;
     }
+    case "execute-task": {
+      const tid = parts[2];
+      const dir = resolveSlicePath(base, mid, sid!);
+      return dir && tid ? join(dir, "tasks", buildTaskFileName(tid, "SUMMARY")) : null;
+    }
+    case "complete-slice": {
+      const dir = resolveSlicePath(base, mid, sid!);
+      return dir ? join(dir, buildSliceFileName(sid!, "SUMMARY")) : null;
+    }
     case "complete-milestone": {
       const dir = resolveMilestonePath(base, mid);
       return dir ? join(dir, buildMilestoneFileName(mid, "SUMMARY")) : null;
@@ -2596,6 +2640,17 @@ export function resolveExpectedArtifactPath(unitType: string, unitId: string, ba
   }
 }
 
+/**
+ * Check whether the expected artifact for a unit exists on disk.
+ * Returns true if the artifact file exists, or if the unit type has no
+ * single verifiable artifact (e.g., replan-slice).
+ */
+function verifyExpectedArtifact(unitType: string, unitId: string, base: string): boolean {
+  const absPath = resolveExpectedArtifactPath(unitType, unitId, base);
+  if (!absPath) return true;
+  return existsSync(absPath);
+}
+
 /**
  * Write a placeholder artifact so the pipeline can advance past a stuck unit.
  * Returns the relative path written, or null if the path couldn't be resolved.

package/src/resources/extensions/gsd/docs/preferences-reference.md

@@ -40,6 +40,14 @@ Full documentation for `~/.gsd/preferences.md` (global) and `.gsd/preferences.md
   - `idle_timeout_minutes`: minutes of inactivity before the supervisor intervenes (default: 10).
   - `hard_timeout_minutes`: minutes before the supervisor forces termination (default: 30).
 
+- `git`: configures GSD's git behavior. All fields are optional — omit any to use defaults. Keys:
+  - `auto_push`: boolean — automatically push commits to the remote after committing. Default: `false`.
+  - `push_branches`: boolean — push newly created slice branches to the remote. Default: `false`.
+  - `remote`: string — git remote name to push to. Default: `"origin"`.
+  - `snapshots`: boolean — create snapshot commits (WIP saves) during long-running tasks. Default: `false`.
+  - `pre_merge_check`: boolean or `"auto"` — run pre-merge checks before merging a slice branch. `true` always runs, `false` never runs, `"auto"` runs when CI is detected. Default: `false`.
+  - `commit_type`: string — override the conventional commit type prefix. Must be one of: `feat`, `fix`, `refactor`, `docs`, `test`, `chore`, `perf`, `ci`, `build`, `style`. Default: inferred from diff content.
+
 ---
 
 ## Best Practices
@@ -101,3 +109,22 @@ skill_rules:
       - find-skills
 ---
 ```
+
+---
+
+## Git Preferences Example
+
+```yaml
+---
+version: 1
+git:
+  auto_push: true
+  push_branches: true
+  remote: origin
+  snapshots: true
+  pre_merge_check: auto
+  commit_type: feat
+---
+```
+
+All git fields are optional. Omit any field to use the default behavior. Project-level preferences override global preferences on a per-field basis.

package/src/resources/extensions/gsd/git-service.ts

@@ -9,7 +9,8 @@
  */
 
 import { execSync } from "node:child_process";
-import { sep } from "node:path";
+import { existsSync, readFileSync } from "node:fs";
+import { join, sep } from "node:path";
 
 import {
   detectWorktreeName,
@@ -39,6 +40,13 @@ export interface MergeSliceResult {
   deletedBranch: boolean;
 }
 
+export interface PreMergeCheckResult {
+  passed: boolean;
+  skipped?: boolean;
+  command?: string;
+  error?: string;
+}
+
 // ─── Constants ─────────────────────────────────────────────────────────────
 
 /**
@@ -61,13 +69,15 @@ export const RUNTIME_EXCLUSION_PATHS: readonly string[] = [
 /**
  * Run a git command in the given directory.
  * Returns trimmed stdout. Throws on non-zero exit unless allowFailure is set.
+ * When `input` is provided, it is piped to stdin.
  */
-export function runGit(basePath: string, args: string[], options: { allowFailure?: boolean } = {}): string {
+export function runGit(basePath: string, args: string[], options: { allowFailure?: boolean; input?: string } = {}): string {
   try {
     return execSync(`git ${args.join(" ")}`, {
       cwd: basePath,
-      stdio: ["ignore", "pipe", "pipe"],
+      stdio: [options.input != null ? "pipe" : "ignore", "pipe", "pipe"],
       encoding: "utf-8",
+      ...(options.input != null ? { input: options.input } : {}),
     }).trim();
   } catch (error) {
     if (options.allowFailure) return "";
@@ -107,7 +117,7 @@ export class GitServiceImpl {
   }
 
   /** Convenience wrapper: run git in this repo's basePath. */
-  private git(args: string[], options: { allowFailure?: boolean } = {}): string {
+  private git(args: string[], options: { allowFailure?: boolean; input?: string } = {}): string {
     return runGit(this.basePath, args, options);
   }
 
@@ -129,6 +139,7 @@ export class GitServiceImpl {
   /**
    * Stage files (smart staging) and commit.
    * Returns the commit message string on success, or null if nothing to commit.
+   * Uses `git commit -F -` with stdin pipe for safe multi-line message handling.
    */
   commit(opts: CommitOptions): string | null {
     this.smartStage();
@@ -137,7 +148,10 @@ export class GitServiceImpl {
     const staged = this.git(["diff", "--cached", "--stat"], { allowFailure: true });
     if (!staged && !opts.allowEmpty) return null;
 
-    this.git(["commit", "-m", JSON.stringify(opts.message), ...(opts.allowEmpty ? ["--allow-empty"] : [])]);
+    this.git(
+      ["commit", "-F", "-", ...(opts.allowEmpty ? ["--allow-empty"] : [])],
+      { input: opts.message },
+    );
     return opts.message;
   }
 
@@ -158,7 +172,7 @@ export class GitServiceImpl {
     if (!staged) return null;
 
     const message = `chore(${unitId}): auto-commit after ${unitType}`;
-    this.git(["commit", "-m", JSON.stringify(message)]);
+    this.git(["commit", "-F", "-"], { input: message });
     return message;
   }
 
@@ -235,6 +249,9 @@ export class GitServiceImpl {
    * branch (preserves planning artifacts). Falls back to main when on another
    * slice branch (avoids chaining slice branches).
    *
+   * When creating a new branch, fetches from remote first (best-effort) to
+   * ensure the local main is up-to-date.
+   *
    * Auto-commits dirty state via smart staging before checkout so runtime
    * files are never accidentally committed during branch switches.
    *
@@ -250,6 +267,24 @@ export class GitServiceImpl {
     let created = false;
 
     if (!this.branchExists(branch)) {
+      // Fetch from remote before creating a new branch (best-effort).
+      const remotes = this.git(["remote"], { allowFailure: true });
+      if (remotes) {
+        const remote = this.prefs.remote ?? "origin";
+        const fetchResult = this.git(["fetch", "--prune", remote], { allowFailure: true });
+        // fetchResult is empty string on both success and allowFailure-caught error.
+        // Check if local is behind upstream (informational only).
+        if (remotes.split("\n").includes(remote)) {
+          const behind = this.git(
+            ["rev-list", "--count", "HEAD..@{upstream}"],
+            { allowFailure: true },
+          );
+          if (behind && parseInt(behind, 10) > 0) {
+            console.error(`GitService: local branch is ${behind} commit(s) behind upstream`);
+          }
+        }
+      }
+
       // Branch from current when it's a normal working branch (not a slice).
       // If already on a slice branch, fall back to main to avoid chaining.
       const mainBranch = this.getMainBranch();
@@ -287,11 +322,170 @@ export class GitServiceImpl {
     this.git(["checkout", mainBranch]);
   }
 
+  // ─── S05 Features ─────────────────────────────────────────────────────
+
+  /**
+   * Create a snapshot ref for the given label (typically a slice branch name).
+   * Gated on prefs.snapshots === true. Ref path: refs/gsd/snapshots/<label>/<timestamp>
+   * The ref points at HEAD, capturing the current commit before destructive operations.
+   */
+  createSnapshot(label: string): void {
+    if (this.prefs.snapshots !== true) return;
+
+    const now = new Date();
+    const ts = now.getFullYear().toString()
+      + String(now.getMonth() + 1).padStart(2, "0")
+      + String(now.getDate()).padStart(2, "0")
+      + "-"
+      + String(now.getHours()).padStart(2, "0")
+      + String(now.getMinutes()).padStart(2, "0")
+      + String(now.getSeconds()).padStart(2, "0");
+
+    const refPath = `refs/gsd/snapshots/${label}/${ts}`;
+    this.git(["update-ref", refPath, "HEAD"]);
+  }
+
+  /**
+   * Run pre-merge verification check. Auto-detects test runner from project
+   * files, or uses custom command from prefs.pre_merge_check.
+   *
+   * Gating:
+   * - `false` → skip (return passed:true, skipped:true)
+   * - non-empty string (not "auto") → use as custom command
+   * - `true`, `"auto"`, or `undefined` → auto-detect from project files
+   *
+   * Auto-detection order:
+   *   package.json scripts.test → npm test
+   *   package.json scripts.build (only if no test) → npm run build
+   *   Cargo.toml → cargo test
+   *   Makefile with test: target → make test
+   *   pyproject.toml → python -m pytest
+   *
+   * If no runner detected in auto mode, returns passed:true (don't block).
+   */
+  runPreMergeCheck(): PreMergeCheckResult {
+    const pref = this.prefs.pre_merge_check;
+
+    // Explicitly disabled
+    if (pref === false) {
+      return { passed: true, skipped: true };
+    }
+
+    let command: string | null = null;
+
+    // Custom string command (not "auto")
+    if (typeof pref === "string" && pref !== "auto" && pref.trim() !== "") {
+      command = pref.trim();
+    }
+
+    // Auto-detect (true, "auto", or undefined)
+    if (command === null) {
+      command = this.detectTestRunner();
+    }
+
+    if (command === null) {
+      return { passed: true, command: "none", error: "no test runner detected" };
+    }
+
+    // Execute the command
+    try {
+      execSync(command, {
+        cwd: this.basePath,
+        timeout: 300_000,
+        stdio: ["ignore", "pipe", "pipe"],
+        encoding: "utf-8",
+      });
+      return { passed: true, command };
+    } catch (err) {
+      const stderr = err instanceof Error && "stderr" in err
+        ? String((err as { stderr: unknown }).stderr).slice(0, 2000)
+        : String(err).slice(0, 2000);
+      return { passed: false, command, error: stderr };
+    }
+  }
+
+  /**
+   * Detect a test/build runner from project files in basePath.
+   * Returns the command string or null if nothing detected.
+   */
+  private detectTestRunner(): string | null {
+    const pkgPath = join(this.basePath, "package.json");
+    if (existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+        if (pkg?.scripts?.test) return "npm test";
+        if (pkg?.scripts?.build) return "npm run build";
+      } catch { /* invalid JSON — skip */ }
+    }
+
+    if (existsSync(join(this.basePath, "Cargo.toml"))) {
+      return "cargo test";
+    }
+
+    const makefilePath = join(this.basePath, "Makefile");
+    if (existsSync(makefilePath)) {
+      try {
+        const content = readFileSync(makefilePath, "utf-8");
+        if (/^test\s*:/m.test(content)) return "make test";
+      } catch { /* skip */ }
+    }
+
+    if (existsSync(join(this.basePath, "pyproject.toml"))) {
+      return "python -m pytest";
+    }
+
+    return null;
+  }
+
   // ─── Merge ─────────────────────────────────────────────────────────────
 
+  /**
+   * Build a rich squash-commit message with a task list from branch commits.
+   *
+   * Format:
+   *   type(scope): title
+   *
+   *   Tasks:
+   *   - commit subject 1
+   *   - commit subject 2
+   *
+   *   Branch: gsd/M001/S01
+   */
+  private buildRichCommitMessage(
+    commitType: string,
+    milestoneId: string,
+    sliceId: string,
+    sliceTitle: string,
+    mainBranch: string,
+    branch: string,
+  ): string {
+    const subject = `${commitType}(${milestoneId}/${sliceId}): ${sliceTitle}`;
+
+    // Collect branch commit subjects
+    const logOutput = this.git(
+      ["log", "--oneline", "--format=%s", `${mainBranch}..${branch}`],
+      { allowFailure: true },
+    );
+
+    if (!logOutput) return subject;
+
+    const subjects = logOutput.split("\n").filter(Boolean);
+    const MAX_ENTRIES = 20;
+    const truncated = subjects.length > MAX_ENTRIES;
+    const displayed = truncated ? subjects.slice(0, MAX_ENTRIES) : subjects;
+
+    const taskLines = displayed.map(s => `- ${s}`).join("\n");
+    const truncationLine = truncated ? `\n- ... and ${subjects.length - MAX_ENTRIES} more` : "";
+
+    return `${subject}\n\nTasks:\n${taskLines}${truncationLine}\n\nBranch: ${branch}`;
+  }
+
   /**
    * Squash-merge a slice branch into main and delete it.
    *
+   * Flow: snapshot branch HEAD → squash merge → rich commit via stdin →
+   * auto-push (if enabled) → delete branch.
+   *
    * Must be called from the main branch. Uses `inferCommitType(sliceTitle)`
    * for the conventional commit type instead of hardcoding `feat`.
    *
@@ -328,20 +522,45 @@ export class GitServiceImpl {
       );
     }
 
+    // Snapshot the branch HEAD before merge (gated on prefs.snapshots)
+    this.createSnapshot(branch);
+
+    // Build rich commit message before squash (needs branch history)
+    const commitType = inferCommitType(sliceTitle);
+    const message = this.buildRichCommitMessage(
+      commitType, milestoneId, sliceId, sliceTitle, mainBranch, branch,
+    );
+
     // Squash merge
     this.git(["merge", "--squash", branch]);
 
-    // Build conventional commit message
-    const commitType = inferCommitType(sliceTitle);
-    const message = `${commitType}(${milestoneId}/${sliceId}): ${sliceTitle}`;
-    this.git(["commit", "-m", JSON.stringify(message)]);
+    // Pre-merge check: run after squash (tests merged result), reset on failure
+    const checkResult = this.runPreMergeCheck();
+    if (!checkResult.passed && !checkResult.skipped) {
+      // Undo the squash merge — nothing committed yet, reset staging area
+      this.git(["reset", "--hard", "HEAD"]);
+      const cmdInfo = checkResult.command ? ` (command: ${checkResult.command})` : "";
+      const errInfo = checkResult.error ? `\n${checkResult.error}` : "";
+      throw new Error(
+        `Pre-merge check failed${cmdInfo}. Merge aborted.${errInfo}`,
+      );
+    }
+
+    // Commit with rich message via stdin pipe
+    this.git(["commit", "-F", "-"], { input: message });
 
     // Delete the merged branch
     this.git(["branch", "-D", branch]);
 
+    // Auto-push to remote if enabled
+    if (this.prefs.auto_push === true) {
+      const remote = this.prefs.remote ?? "origin";
+      this.git(["push", remote, mainBranch], { allowFailure: true });
+    }
+
     return {
       branch,
-      mergedCommitMessage: message,
+      mergedCommitMessage: `${commitType}(${milestoneId}/${sliceId}): ${sliceTitle}`,
       deletedBranch: true,
     };
   }