gsd-pi 2.47.0 → 2.48.0-dev.ced2eca

package/dist/resources/extensions/gsd/auto-dispatch.js

@@ -8,7 +8,7 @@
  * data structure that is inspectable, testable per-rule, and extensible
  * without modifying orchestration code.
  */
-import { loadFile, loadActiveOverrides } from "./files.js";
+import { loadFile, extractUatType, loadActiveOverrides } from "./files.js";
 import { isDbAvailable, getMilestoneSlices } from "./gsd-db.js";
 import { resolveMilestoneFile, resolveMilestonePath, resolveSliceFile, resolveTaskFile, relSliceFile, buildMilestoneFileName, } from "./paths.js";
 import { existsSync, mkdirSync, writeFileSync } from "node:fs";
@@ -112,7 +112,22 @@ export const DISPATCH_RULES = [
                     continue;
                 const verdictMatch = content.match(/verdict:\s*([\w-]+)/i);
                 const verdict = verdictMatch?.[1]?.toLowerCase();
-                if (verdict && verdict !== "pass" && verdict !== "passed") {
+                // Determine acceptable verdicts based on UAT type.
+                // mixed / human-experience / live-runtime modes may legitimately
+                // produce PARTIAL when all automatable checks pass but human-only
+                // checks remain — this should not block progression.
+                const acceptableVerdicts = ["pass", "passed"];
+                const uatFile = resolveSliceFile(basePath, mid, sliceId, "UAT");
+                if (uatFile) {
+                    const uatContent = await loadFile(uatFile);
+                    if (uatContent) {
+                        const uatType = extractUatType(uatContent);
+                        if (uatType === "mixed" || uatType === "human-experience" || uatType === "live-runtime") {
+                            acceptableVerdicts.push("partial");
+                        }
+                    }
+                }
+                if (verdict && !acceptableVerdicts.includes(verdict)) {
                     return {
                         action: "stop",
                         reason: `UAT verdict for ${sliceId} is "${verdict}" — blocking progression until resolved.\nReview the UAT result and update the verdict to PASS, or re-run /gsd auto after fixing.`,

package/dist/resources/extensions/gsd/auto-post-unit.js

@@ -26,6 +26,15 @@ import { consumeSignal } from "./session-status-io.js";
 import { checkPostUnitHooks, isRetryPending, consumeRetryTrigger, persistHookState, resolveHookArtifactPath, } from "./post-unit-hooks.js";
 import { hasPendingCaptures, loadPendingCaptures } from "./captures.js";
 import { debugLog } from "./debug-logger.js";
+/** Unit types that only touch `.gsd/` internal state files (no code changes).
+ *  Auto-commit is skipped for these — their state files are picked up by the
+ *  next actual task commit via `smartStage()`. */
+const LIFECYCLE_ONLY_UNITS = new Set([
+    "research-milestone", "discuss-milestone", "plan-milestone",
+    "validate-milestone", "research-slice", "plan-slice",
+    "replan-slice", "complete-slice", "run-uat",
+    "reassess-roadmap", "rewrite-docs",
+]);
 import { existsSync, unlinkSync } from "node:fs";
 import { join } from "node:path";
 import { _resetHasChangesCache } from "./native-git-bridge.js";
@@ -210,9 +219,14 @@ export async function postUnitPreVerification(pctx, opts) {
             // code files only in the working tree where they are destroyed by
             // `git worktree remove --force` during teardown.
             _resetHasChangesCache();
-            const commitMsg = autoCommitCurrentBranch(s.basePath, s.currentUnit.type, s.currentUnit.id, taskContext);
-            if (commitMsg) {
-                ctx.ui.notify(`Committed: ${commitMsg.split("\n")[0]}`, "info");
+            // Skip auto-commit for lifecycle-only units (#2553) — they only touch
+            // `.gsd/` internal state files. Those files are picked up by the next
+            // actual task commit via smartStage().
+            if (!LIFECYCLE_ONLY_UNITS.has(s.currentUnit.type)) {
+                const commitMsg = autoCommitCurrentBranch(s.basePath, s.currentUnit.type, s.currentUnit.id, taskContext);
+                if (commitMsg) {
+                    ctx.ui.notify(`Committed: ${commitMsg.split("\n")[0]}`, "info");
+                }
             }
         }
         catch (e) {

package/dist/resources/extensions/gsd/auto-start.js

@@ -30,7 +30,7 @@ import { initRoutingHistory } from "./routing-history.js";
 import { restoreHookState, resetHookState } from "./post-unit-hooks.js";
 import { resetProactiveHealing, setLevelChangeCallback } from "./doctor-proactive.js";
 import { snapshotSkills } from "./skill-discovery.js";
-import { isDbAvailable } from "./gsd-db.js";
+import { isDbAvailable, getMilestone } from "./gsd-db.js";
 import { hideFooter } from "./auto-dashboard.js";
 import { debugLog, enableDebug, isDebugEnabled, getDebugLogPath, } from "./debug-logger.js";
 import { existsSync, mkdirSync, readdirSync, statSync, unlinkSync, } from "node:fs";
@@ -503,6 +503,13 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
                 if (milestoneIds.length > 1) {
                     const issues = [];
                     for (const id of milestoneIds) {
+                        // Skip completed/parked milestones — a leftover CONTEXT-DRAFT.md
+                        // on a finished milestone is harmless residue, not an actionable warning.
+                        if (isDbAvailable()) {
+                            const ms = getMilestone(id);
+                            if (ms?.status === "complete" || ms?.status === "parked")
+                                continue;
+                        }
                         const draft = resolveMilestoneFile(base, id, "CONTEXT-DRAFT");
                         if (draft)
                             issues.push(`${id}: has CONTEXT-DRAFT.md (will pause for discussion)`);

package/dist/resources/extensions/gsd/auto-worktree.js

@@ -910,13 +910,16 @@ export function mergeMilestoneToMain(originalBasePath_, milestoneId, roadmapCont
             milestoneTitle = titleMatch[1].trim();
     }
     milestoneTitle = milestoneTitle || milestoneId;
-    const subject = `feat(${milestoneId}): ${milestoneTitle}`;
+    const subject = `feat: ${milestoneTitle}`;
     let body = "";
     if (completedSlices.length > 0) {
         const sliceLines = completedSlices
             .map((s) => `- ${s.id}: ${s.title}`)
             .join("\n");
-        body = `\n\nCompleted slices:\n${sliceLines}\n\nBranch: ${milestoneBranch}`;
+        body = `\n\nCompleted slices:\n${sliceLines}\n\nGSD-Milestone: ${milestoneId}\nBranch: ${milestoneBranch}`;
+    }
+    else {
+        body = `\n\nGSD-Milestone: ${milestoneId}\nBranch: ${milestoneBranch}`;
     }
     const commitMessage = subject + body;
     // 6b. Reconcile worktree HEAD with milestone branch ref (#1846).

package/dist/resources/extensions/gsd/commands/handlers/auto.js

@@ -1,7 +1,27 @@
+import { existsSync, readFileSync } from "node:fs";
+import { resolve } from "node:path";
 import { enableDebug } from "../../debug-logger.js";
 import { isAutoActive, isAutoPaused, pauseAuto, startAuto, stopAuto, stopAutoRemote } from "../../auto.js";
 import { handleRate } from "../../commands-rate.js";
 import { guardRemoteSession, projectRoot } from "../context.js";
+/**
+ * Parse --yolo flag and optional file path from the auto command string.
+ * Supports: `/gsd auto --yolo path/to/file.md` or `/gsd auto -y path/to/file.md`
+ */
+function parseYoloFlag(trimmed) {
+    const yoloRe = /(?:--yolo|-y)\s+("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|\S+)/;
+    const match = trimmed.match(yoloRe);
+    if (!match)
+        return { yoloSeedFile: null, rest: trimmed };
+    // Strip quotes if present
+    let filePath = match[1];
+    if ((filePath.startsWith('"') && filePath.endsWith('"')) ||
+        (filePath.startsWith("'") && filePath.endsWith("'"))) {
+        filePath = filePath.slice(1, -1);
+    }
+    const rest = trimmed.replace(match[0], "").replace(/\s+/g, " ").trim();
+    return { yoloSeedFile: filePath, rest };
+}
 export async function handleAutoCommand(trimmed, ctx, pi) {
     if (trimmed === "next" || trimmed.startsWith("next ")) {
         if (trimmed.includes("--dry-run")) {
@@ -19,13 +39,33 @@ export async function handleAutoCommand(trimmed, ctx, pi) {
         return true;
     }
     if (trimmed === "auto" || trimmed.startsWith("auto ")) {
-        const verboseMode = trimmed.includes("--verbose");
-        const debugMode = trimmed.includes("--debug");
+        const { yoloSeedFile, rest } = parseYoloFlag(trimmed);
+        const verboseMode = rest.includes("--verbose");
+        const debugMode = rest.includes("--debug");
         if (debugMode)
             enableDebug(projectRoot());
         if (!(await guardRemoteSession(ctx, pi)))
             return true;
-        await startAuto(ctx, pi, projectRoot(), verboseMode);
+        if (yoloSeedFile) {
+            const resolved = resolve(projectRoot(), yoloSeedFile);
+            if (!existsSync(resolved)) {
+                ctx.ui.notify(`Yolo seed file not found: ${resolved}`, "error");
+                return true;
+            }
+            const seedContent = readFileSync(resolved, "utf-8").trim();
+            if (!seedContent) {
+                ctx.ui.notify(`Yolo seed file is empty: ${resolved}`, "error");
+                return true;
+            }
+            // Headless path: bootstrap project, dispatch non-interactive discuss,
+            // then auto-mode starts automatically via checkAutoStartAfterDiscuss
+            // when the LLM says "Milestone X ready."
+            const { showHeadlessMilestoneCreation } = await import("../../guided-flow.js");
+            await showHeadlessMilestoneCreation(ctx, pi, projectRoot(), seedContent);
+        }
+        else {
+            await startAuto(ctx, pi, projectRoot(), verboseMode);
+        }
         return true;
     }
     if (trimmed === "stop") {

package/dist/resources/extensions/gsd/forensics.js

@@ -197,7 +197,11 @@ export async function buildForensicReport(basePath) {
     // Extensions run from ~/.gsd/agent/extensions/gsd/ at runtime, so path-traversal
     // from import.meta.url would resolve to ~/package.json (wrong on every system).
     const gsdVersion = process.env.GSD_VERSION || "unknown";
-    // 9. Run anomaly detectors
+    // 9. Scan journal for flow timeline and structured events
+    const journalSummary = scanJournalForForensics(basePath);
+    // 10. Gather activity log directory metadata
+    const activityLogMeta = gatherActivityLogMeta(basePath, activeMilestone);
+    // 11. Run anomaly detectors
     if (metrics?.units)
         detectStuckLoops(metrics.units, anomalies);
     if (metrics?.units)
@@ -207,6 +211,7 @@ export async function buildForensicReport(basePath) {
     detectCrash(crashLock, anomalies);
     detectDoctorIssues(doctorIssues, anomalies);
     detectErrorTraces(unitTraces, anomalies);
+    detectJournalAnomalies(journalSummary, anomalies);
     return {
         gsdVersion,
         timestamp: new Date().toISOString(),
@@ -221,10 +226,14 @@ export async function buildForensicReport(basePath) {
         doctorIssues,
         anomalies,
         recentUnits,
+        journalSummary,
+        activityLogMeta,
     };
 }
 // ─── Activity Log Scanner ─────────────────────────────────────────────────────
 const ACTIVITY_FILENAME_RE = /^(\d+)-(.+?)-(.+)\.jsonl$/;
+/** Threshold below which iteration cadence is considered rapid (thrashing). */
+const RAPID_ITERATION_THRESHOLD_MS = 5000;
 function scanActivityLogs(basePath, activeMilestone) {
     const activityDirs = resolveActivityDirs(basePath, activeMilestone);
     const allTraces = [];
@@ -292,6 +301,152 @@ function resolveActivityDirs(basePath, activeMilestone) {
     dirs.push(rootActivityDir);
     return dirs;
 }
+// ─── Journal Scanner ──────────────────────────────────────────────────────────
+/**
+ * Max recent journal files to fully parse for event counts and recent events.
+ * Older files are line-counted only to avoid loading huge amounts of data.
+ */
+const MAX_JOURNAL_RECENT_FILES = 3;
+/** Max recent events to extract for the forensic report timeline. */
+const MAX_JOURNAL_RECENT_EVENTS = 20;
+/**
+ * Intelligently scan journal files for forensic summary.
+ *
+ * Journal files can be huge (thousands of JSONL entries over weeks of auto-mode).
+ * Instead of loading all entries into memory:
+ * - Only fully parse the most recent N daily files (event counts, flow tracking)
+ * - Line-count older files for approximate totals (no JSON parsing)
+ * - Extract only the last 20 events for the timeline
+ */
+function scanJournalForForensics(basePath) {
+    try {
+        const journalDir = join(gsdRoot(basePath), "journal");
+        if (!existsSync(journalDir))
+            return null;
+        const files = readdirSync(journalDir).filter(f => f.endsWith(".jsonl")).sort();
+        if (files.length === 0)
+            return null;
+        // Split into recent (fully parsed) and older (line-counted only)
+        const recentFiles = files.slice(-MAX_JOURNAL_RECENT_FILES);
+        const olderFiles = files.slice(0, -MAX_JOURNAL_RECENT_FILES);
+        // Line-count older files without parsing — avoids loading megabytes of JSON
+        let olderEntryCount = 0;
+        let oldestEntry = null;
+        for (const file of olderFiles) {
+            try {
+                const raw = readFileSync(join(journalDir, file), "utf-8");
+                const lines = raw.split("\n");
+                for (const line of lines) {
+                    if (!line.trim())
+                        continue;
+                    olderEntryCount++;
+                    // Extract only the timestamp from the first non-empty line of the oldest file
+                    if (!oldestEntry) {
+                        try {
+                            const parsed = JSON.parse(line);
+                            if (parsed.ts)
+                                oldestEntry = parsed.ts;
+                        }
+                        catch { /* skip malformed */ }
+                    }
+                }
+            }
+            catch { /* skip unreadable files */ }
+        }
+        // Fully parse recent files for event counts and timeline
+        const eventCounts = {};
+        const flowIds = new Set();
+        const recentParsedEntries = [];
+        let recentEntryCount = 0;
+        for (const file of recentFiles) {
+            try {
+                const raw = readFileSync(join(journalDir, file), "utf-8");
+                for (const line of raw.split("\n")) {
+                    if (!line.trim())
+                        continue;
+                    try {
+                        const entry = JSON.parse(line);
+                        recentEntryCount++;
+                        eventCounts[entry.eventType] = (eventCounts[entry.eventType] ?? 0) + 1;
+                        flowIds.add(entry.flowId);
+                        if (!oldestEntry)
+                            oldestEntry = entry.ts;
+                        // Keep a rolling window of last N events — avoids accumulating unbounded arrays
+                        recentParsedEntries.push({
+                            ts: entry.ts,
+                            flowId: entry.flowId,
+                            eventType: entry.eventType,
+                            rule: entry.rule,
+                            unitId: entry.data?.unitId,
+                        });
+                        if (recentParsedEntries.length > MAX_JOURNAL_RECENT_EVENTS) {
+                            recentParsedEntries.shift();
+                        }
+                    }
+                    catch { /* skip malformed lines */ }
+                }
+            }
+            catch { /* skip unreadable files */ }
+        }
+        const totalEntries = olderEntryCount + recentEntryCount;
+        if (totalEntries === 0)
+            return null;
+        const newestEntry = recentParsedEntries.length > 0
+            ? recentParsedEntries[recentParsedEntries.length - 1].ts
+            : null;
+        return {
+            totalEntries,
+            flowCount: flowIds.size,
+            eventCounts,
+            recentEvents: recentParsedEntries,
+            oldestEntry,
+            newestEntry,
+            fileCount: files.length,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+// ─── Activity Log Metadata ────────────────────────────────────────────────────
+function gatherActivityLogMeta(basePath, activeMilestone) {
+    try {
+        const activityDirs = resolveActivityDirs(basePath, activeMilestone);
+        let fileCount = 0;
+        let totalSizeBytes = 0;
+        let oldestFile = null;
+        let newestFile = null;
+        let oldestMtime = Infinity;
+        let newestMtime = 0;
+        for (const activityDir of activityDirs) {
+            if (!existsSync(activityDir))
+                continue;
+            const files = readdirSync(activityDir).filter(f => f.endsWith(".jsonl"));
+            for (const file of files) {
+                const filePath = join(activityDir, file);
+                const stat = statSync(filePath, { throwIfNoEntry: false });
+                if (!stat)
+                    continue;
+                fileCount++;
+                totalSizeBytes += stat.size;
+                if (stat.mtimeMs < oldestMtime) {
+                    oldestMtime = stat.mtimeMs;
+                    oldestFile = file;
+                }
+                if (stat.mtimeMs > newestMtime) {
+                    newestMtime = stat.mtimeMs;
+                    newestFile = file;
+                }
+            }
+        }
+        if (fileCount === 0)
+            return null;
+        return { fileCount, totalSizeBytes, oldestFile, newestFile };
+    }
+    catch {
+        return null;
+    }
+}
 // ─── Completed Keys Loader ────────────────────────────────────────────────────
 function loadCompletedKeys(basePath) {
     const file = join(gsdRoot(basePath), "completed-units.json");
@@ -423,6 +578,64 @@ function detectErrorTraces(traces, anomalies) {
         }
     }
 }
+function detectJournalAnomalies(journal, anomalies) {
+    if (!journal)
+        return;
+    // Detect stuck-detected events from the journal
+    const stuckCount = journal.eventCounts["stuck-detected"] ?? 0;
+    if (stuckCount > 0) {
+        anomalies.push({
+            type: "journal-stuck",
+            severity: stuckCount >= 3 ? "error" : "warning",
+            summary: `Journal recorded ${stuckCount} stuck-detected event(s)`,
+            details: `The auto-mode loop detected it was stuck ${stuckCount} time(s). Check journal events for flow IDs and causal chains to trace the root cause.`,
+        });
+    }
+    // Detect guard-block events (dispatch was blocked by a guard)
+    const guardCount = journal.eventCounts["guard-block"] ?? 0;
+    if (guardCount > 0) {
+        anomalies.push({
+            type: "journal-guard-block",
+            severity: guardCount >= 5 ? "warning" : "info",
+            summary: `Journal recorded ${guardCount} guard-block event(s)`,
+            details: `Dispatch was blocked by a guard condition ${guardCount} time(s). This may indicate a persistent blocking condition preventing progress.`,
+        });
+    }
+    // Detect rapid iterations (many flows in short time = likely thrashing)
+    if (journal.flowCount > 0 && journal.oldestEntry && journal.newestEntry) {
+        const oldest = new Date(journal.oldestEntry).getTime();
+        const newest = new Date(journal.newestEntry).getTime();
+        const spanMs = newest - oldest;
+        if (spanMs > 0 && journal.flowCount > 10) {
+            const avgMs = spanMs / journal.flowCount;
+            if (avgMs < RAPID_ITERATION_THRESHOLD_MS) {
+                anomalies.push({
+                    type: "journal-rapid-iterations",
+                    severity: "warning",
+                    summary: `${journal.flowCount} iterations in ${formatDuration(spanMs)} (avg ${formatDuration(avgMs)}/iteration)`,
+                    details: `Unusually rapid iteration cadence suggests the loop may be thrashing without making progress. Review recent journal events for dispatch-stop or terminal events.`,
+                });
+            }
+        }
+    }
+    // Detect worktree failures from journal events
+    const wtCreateFailed = journal.eventCounts["worktree-create-failed"] ?? 0;
+    const wtMergeFailed = journal.eventCounts["worktree-merge-failed"] ?? 0;
+    const wtFailures = wtCreateFailed + wtMergeFailed;
+    if (wtFailures > 0) {
+        const parts = [];
+        if (wtCreateFailed > 0)
+            parts.push(`${wtCreateFailed} create failure(s)`);
+        if (wtMergeFailed > 0)
+            parts.push(`${wtMergeFailed} merge failure(s)`);
+        anomalies.push({
+            type: "journal-worktree-failure",
+            severity: "warning",
+            summary: `Worktree failures: ${parts.join(", ")}`,
+            details: `Journal recorded worktree operation failures. These may indicate git state corruption or conflicting branches.`,
+        });
+    }
+}
 // ─── Report Persistence ───────────────────────────────────────────────────────
 function saveForensicReport(basePath, report, problemDescription) {
     const dir = join(gsdRoot(basePath), "forensics");
@@ -491,6 +704,48 @@ function saveForensicReport(basePath, report, problemDescription) {
         sections.push(`## Crash Lock`, ``);
         sections.push(redact(formatCrashInfo(report.crashLock)), ``);
     }
+    // Activity log metadata
+    if (report.activityLogMeta) {
+        const meta = report.activityLogMeta;
+        sections.push(`## Activity Log Metadata`, ``);
+        sections.push(`- Files: ${meta.fileCount}`);
+        sections.push(`- Total size: ${(meta.totalSizeBytes / 1024).toFixed(1)} KB`);
+        if (meta.oldestFile)
+            sections.push(`- Oldest: ${meta.oldestFile}`);
+        if (meta.newestFile)
+            sections.push(`- Newest: ${meta.newestFile}`);
+        sections.push(``);
+    }
+    // Journal summary
+    if (report.journalSummary) {
+        const js = report.journalSummary;
+        sections.push(`## Journal Summary`, ``);
+        sections.push(`- Total entries: ${js.totalEntries}`);
+        sections.push(`- Distinct flows (iterations): ${js.flowCount}`);
+        sections.push(`- Daily files: ${js.fileCount}`);
+        if (js.oldestEntry)
+            sections.push(`- Date range: ${js.oldestEntry} — ${js.newestEntry}`);
+        sections.push(``);
+        sections.push(`### Event Type Distribution`, ``);
+        sections.push(`| Event Type | Count |`);
+        sections.push(`|------------|-------|`);
+        for (const [evType, count] of Object.entries(js.eventCounts).sort((a, b) => b[1] - a[1])) {
+            sections.push(`| ${evType} | ${count} |`);
+        }
+        sections.push(``);
+        if (js.recentEvents.length > 0) {
+            sections.push(`### Recent Journal Events (last ${js.recentEvents.length})`, ``);
+            for (const ev of js.recentEvents) {
+                const parts = [`${ev.ts} [${ev.eventType}] flow=${ev.flowId.slice(0, 8)}`];
+                if (ev.rule)
+                    parts.push(`rule=${ev.rule}`);
+                if (ev.unitId)
+                    parts.push(`unit=${ev.unitId}`);
+                sections.push(`- ${parts.join(" ")}`);
+            }
+            sections.push(``);
+        }
+    }
     writeFileSync(filePath, sections.join("\n"), "utf-8");
     return filePath;
 }
@@ -565,6 +820,42 @@ function formatReportForPrompt(report) {
         sections.push(`- Total duration: ${formatDuration(totals.duration)}`);
         sections.push("");
     }
+    // Activity log metadata
+    if (report.activityLogMeta) {
+        const meta = report.activityLogMeta;
+        sections.push("### Activity Log Overview");
+        sections.push(`- Files: ${meta.fileCount}, Total size: ${(meta.totalSizeBytes / 1024).toFixed(1)} KB`);
+        if (meta.oldestFile)
+            sections.push(`- Oldest: ${meta.oldestFile}`);
+        if (meta.newestFile)
+            sections.push(`- Newest: ${meta.newestFile}`);
+        sections.push("");
+    }
+    // Journal summary — structured event timeline
+    if (report.journalSummary) {
+        const js = report.journalSummary;
+        sections.push("### Journal Summary (Iteration Event Log)");
+        sections.push(`- Total entries: ${js.totalEntries}, Distinct flows: ${js.flowCount}, Daily files: ${js.fileCount}`);
+        if (js.oldestEntry)
+            sections.push(`- Date range: ${js.oldestEntry} — ${js.newestEntry}`);
+        // Event type distribution (compact)
+        const eventPairs = Object.entries(js.eventCounts).sort((a, b) => b[1] - a[1]);
+        sections.push(`- Events: ${eventPairs.map(([t, c]) => `${t}(${c})`).join(", ")}`);
+        // Recent events timeline (for tracing what just happened)
+        if (js.recentEvents.length > 0) {
+            sections.push("");
+            sections.push(`**Recent Journal Events (last ${js.recentEvents.length}):**`);
+            for (const ev of js.recentEvents) {
+                const parts = [`${ev.ts} [${ev.eventType}] flow=${ev.flowId.slice(0, 8)}`];
+                if (ev.rule)
+                    parts.push(`rule=${ev.rule}`);
+                if (ev.unitId)
+                    parts.push(`unit=${ev.unitId}`);
+                sections.push(`- ${parts.join(" ")}`);
+            }
+        }
+        sections.push("");
+    }
     // Completed keys count
     sections.push(`### Completed Keys: ${report.completedKeys.length}`);
     sections.push(`### GSD Version: ${report.gsdVersion}`);

package/dist/resources/extensions/gsd/git-service.js

@@ -20,21 +20,23 @@ import { getErrorMessage } from "./error-utils.js";
 export const VALID_BRANCH_NAME = /^[a-zA-Z0-9_\-\/.]+$/;
 /**
  * Build a meaningful conventional commit message from task execution context.
- * Format: `{type}({sliceId}/{taskId}): {description}`
+ * Format: `{type}: {description}` (clean conventional commit — no GSD IDs in subject).
+ *
+ * GSD metadata is placed in a `GSD-Task:` git trailer at the end of the body,
+ * following the same convention as `Signed-off-by:` or `Co-Authored-By:`.
  *
  * The description is the task summary one-liner if available (it describes
  * what was actually built), falling back to the task title (what was planned).
  */
 export function buildTaskCommitMessage(ctx) {
-    const scope = ctx.taskId; // e.g. "S01/T02" or just "T02"
     const description = ctx.oneLiner || ctx.taskTitle;
     const type = inferCommitType(ctx.taskTitle, ctx.oneLiner);
-    // Truncate description to ~72 chars for subject line
-    const maxDescLen = 68 - type.length - scope.length;
+    // Truncate description to ~72 chars for subject line (full budget without scope)
+    const maxDescLen = 70 - type.length;
     const truncated = description.length > maxDescLen
         ? description.slice(0, maxDescLen - 1).trimEnd() + "…"
         : description;
-    const subject = `${type}(${scope}): ${truncated}`;
+    const subject = `${type}: ${truncated}`;
     // Build body with key files if available
     const bodyParts = [];
     if (ctx.keyFiles && ctx.keyFiles.length > 0) {
@@ -44,13 +46,12 @@ export function buildTaskCommitMessage(ctx) {
             .join("\n");
         bodyParts.push(fileLines);
     }
+    // Trailers: GSD-Task first, then Resolves
+    bodyParts.push(`GSD-Task: ${ctx.taskId}`);
     if (ctx.issueNumber) {
         bodyParts.push(`Resolves #${ctx.issueNumber}`);
     }
-    if (bodyParts.length > 0) {
-        return `${subject}\n\n${bodyParts.join("\n\n")}`;
-    }
-    return subject;
+    return `${subject}\n\n${bodyParts.join("\n\n")}`;
 }
 /**
  * Thrown when a slice merge hits code conflicts in non-.gsd files.
@@ -385,7 +386,7 @@ export class GitServiceImpl {
             return null;
         const message = taskContext
             ? buildTaskCommitMessage(taskContext)
-            : `chore(${unitId}): auto-commit after ${unitType}`;
+            : `chore: auto-commit after ${unitType}\n\nGSD-Unit: ${unitId}`;
         nativeCommit(this.basePath, message, { allowEmpty: false });
         return message;
     }