gsd-pi 2.33.1-dev.ee47f1b → 2.34.0-dev.bbb5216

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

@@ -4,8 +4,6 @@
 import { resolvePostUnitHooks, resolvePreDispatchHooks } from "./preferences.js";
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
-import { gsdRoot } from "./paths.js";
-import { parseUnitId } from "./unit-id.js";
 // ─── Hook Queue State ──────────────────────────────────────────────────────
 /** Currently executing hook, or null if in normal dispatch flow. */
 let activeHook = null;
@@ -112,7 +110,7 @@ function dequeueNextHook(basePath) {
             pendingRetry: false,
         };
         // Build the prompt with variable substitution
-        const { milestone: mid, slice: sid, task: tid } = parseUnitId(triggerUnitId);
+        const [mid, sid, tid] = triggerUnitId.split("/");
         const prompt = config.prompt
             .replace(/\{milestoneId\}/g, mid ?? "")
             .replace(/\{sliceId\}/g, sid ?? "")
@@ -164,14 +162,16 @@ function handleHookCompletion(basePath) {
  *   - Milestone-level (M001):    .gsd/M001/{artifact}
  */
 export function resolveHookArtifactPath(basePath, unitId, artifactName) {
-    const { milestone: mid, slice: sid, task: tid } = parseUnitId(unitId);
-    if (mid && sid && tid) {
-        return join(gsdRoot(basePath), mid, "slices", sid, "tasks", `${tid}-${artifactName}`);
+    const parts = unitId.split("/");
+    if (parts.length === 3) {
+        const [mid, sid, tid] = parts;
+        return join(basePath, ".gsd", mid, "slices", sid, "tasks", `${tid}-${artifactName}`);
     }
-    if (mid && sid) {
-        return join(gsdRoot(basePath), mid, "slices", sid, artifactName);
+    if (parts.length === 2) {
+        const [mid, sid] = parts;
+        return join(basePath, ".gsd", mid, "slices", sid, artifactName);
     }
-    return join(gsdRoot(basePath), mid, artifactName);
+    return join(basePath, ".gsd", parts[0], artifactName);
 }
 // ═══════════════════════════════════════════════════════════════════════════
 // Phase 2: Pre-Dispatch Hooks
@@ -196,7 +196,7 @@ export function runPreDispatchHooks(unitType, unitId, prompt, basePath) {
     if (hooks.length === 0) {
         return { action: "proceed", prompt, firedHooks: [] };
     }
-    const { milestone: mid, slice: sid, task: tid } = parseUnitId(unitId);
+    const [mid, sid, tid] = unitId.split("/");
     const substitute = (text) => text
         .replace(/\{milestoneId\}/g, mid ?? "")
         .replace(/\{sliceId\}/g, sid ?? "")
@@ -246,7 +246,7 @@ export function runPreDispatchHooks(unitType, unitId, prompt, basePath) {
 // ═══════════════════════════════════════════════════════════════════════════
 const HOOK_STATE_FILE = "hook-state.json";
 function hookStatePath(basePath) {
-    return join(gsdRoot(basePath), HOOK_STATE_FILE);
+    return join(basePath, ".gsd", HOOK_STATE_FILE);
 }
 /**
  * Persist current hook cycle counts to disk so they survive crashes/restarts.
@@ -258,7 +258,7 @@ export function persistHookState(basePath) {
         savedAt: new Date().toISOString(),
     };
     try {
-        const dir = gsdRoot(basePath);
+        const dir = join(basePath, ".gsd");
         if (!existsSync(dir))
             mkdirSync(dir, { recursive: true });
         writeFileSync(hookStatePath(basePath), JSON.stringify(state, null, 2), "utf-8");
@@ -386,7 +386,7 @@ export function triggerHookManually(hookName, unitType, unitId, basePath) {
     // Update active hook with the cycle count
     activeHook.cycle = currentCycle;
     // Build the prompt with variable substitution
-    const { milestone: mid, slice: sid, task: tid } = parseUnitId(unitId);
+    const [mid, sid, tid] = unitId.split("/");
     const prompt = hook.prompt
         .replace(/\{milestoneId\}/g, mid ?? "")
         .replace(/\{sliceId\}/g, sid ?? "")

package/dist/resources/extensions/gsd/progress-score.js

@@ -10,188 +10,93 @@
  * tracking, stuck detection counters, and working-tree activity.
  */
 import { getHealthTrend, getConsecutiveErrorUnits, getHealthHistory, } from "./doctor-proactive.js";
-// ── Signal Evaluators ──────────────────────────────────────────────────────
-function evaluateHealthTrend() {
+function escalateLevel(level, next) {
+    const ranks = {
+        green: 0,
+        yellow: 1,
+        red: 2,
+    };
+    return ranks[next] > ranks[level] ? next : level;
+}
+// ── Public API ──────────────────────────────────────────────────────────────
+/**
+ * Compute the current progress score from health signals.
+ */
+export function computeProgressScore() {
+    const signals = [];
+    let level = "green";
+    // Check consecutive errors
+    const consecutiveErrors = getConsecutiveErrorUnits();
+    if (consecutiveErrors >= 3) {
+        signals.push({ kind: "negative", label: `${consecutiveErrors} consecutive error units` });
+        level = escalateLevel(level, "red");
+    }
+    else if (consecutiveErrors >= 1) {
+        signals.push({ kind: "negative", label: `${consecutiveErrors} consecutive error unit(s)` });
+        level = escalateLevel(level, "yellow");
+    }
+    // Check health trend
     const trend = getHealthTrend();
-    switch (trend) {
-        case "improving":
-            return { name: "health_trend", level: "green", detail: "Health improving" };
-        case "stable":
-            return { name: "health_trend", level: "green", detail: "Health stable" };
-        case "degrading":
-            return { name: "health_trend", level: "red", detail: "Health degrading" };
-        case "unknown":
-            return { name: "health_trend", level: "green", detail: "Insufficient data" };
+    if (trend === "degrading") {
+        signals.push({ kind: "negative", label: "Health trend declining" });
+        level = escalateLevel(level, "yellow");
     }
-}
-function evaluateErrorStreak() {
-    const streak = getConsecutiveErrorUnits();
-    if (streak === 0) {
-        return { name: "error_streak", level: "green", detail: "No consecutive errors" };
+    else if (trend === "improving") {
+        signals.push({ kind: "positive", label: "Health trend improving" });
     }
-    if (streak <= 2) {
-        return { name: "error_streak", level: "yellow", detail: `${streak} consecutive error unit(s)` };
+    else if (trend === "stable") {
+        signals.push({ kind: "neutral", label: "Health trend stable" });
     }
-    return { name: "error_streak", level: "red", detail: `${streak} consecutive error units` };
-}
-function evaluateRecentErrors() {
+    // Check recent history
     const history = getHealthHistory();
     if (history.length === 0) {
-        return { name: "recent_errors", level: "green", detail: "No health data yet" };
-    }
-    const latest = history[history.length - 1];
-    if (latest.errors === 0 && latest.warnings <= 1) {
-        return { name: "recent_errors", level: "green", detail: `${latest.errors}E/${latest.warnings}W` };
-    }
-    if (latest.errors === 0) {
-        return { name: "recent_errors", level: "yellow", detail: `${latest.warnings} warning(s)` };
-    }
-    if (latest.errors <= 2) {
-        return { name: "recent_errors", level: "yellow", detail: `${latest.errors} error(s), ${latest.warnings} warning(s)` };
-    }
-    return { name: "recent_errors", level: "red", detail: `${latest.errors} error(s), ${latest.warnings} warning(s)` };
-}
-function evaluateArtifactProduction() {
-    const history = getHealthHistory();
-    if (history.length < 2) {
-        return { name: "artifact_production", level: "green", detail: "Insufficient data" };
-    }
-    const totalFixes = history.reduce((sum, s) => sum + s.fixesApplied, 0);
-    const recent = history.slice(-3);
-    const recentFixes = recent.reduce((sum, s) => sum + s.fixesApplied, 0);
-    // If recent units are all producing fixes but errors aren't decreasing,
-    // doctor is fighting fires but not making headway
-    if (recentFixes > 3 && recent.every(s => s.errors > 0)) {
-        return { name: "artifact_production", level: "yellow", detail: "Doctor applying fixes but errors persist" };
-    }
-    return { name: "artifact_production", level: "green", detail: `${totalFixes} total fixes applied` };
-}
-function evaluateDispatchVelocity() {
-    const history = getHealthHistory();
-    if (history.length < 3) {
-        return { name: "dispatch_velocity", level: "green", detail: "Insufficient data" };
-    }
-    // Check time between recent snapshots — are units completing at a reasonable rate?
-    const recent = history.slice(-5);
-    if (recent.length < 2) {
-        return { name: "dispatch_velocity", level: "green", detail: "Insufficient data" };
-    }
-    const timeDiffs = [];
-    for (let i = 1; i < recent.length; i++) {
-        timeDiffs.push(recent[i].timestamp - recent[i - 1].timestamp);
+        signals.push({ kind: "neutral", label: "No health data yet" });
     }
-    const avgTimeMs = timeDiffs.reduce((a, b) => a + b, 0) / timeDiffs.length;
-    const avgTimeMins = Math.round(avgTimeMs / 60_000);
-    // If average unit time is > 15 minutes, something might be wrong
-    if (avgTimeMins > 15) {
-        return { name: "dispatch_velocity", level: "yellow", detail: `Units averaging ${avgTimeMins}min each` };
-    }
-    return { name: "dispatch_velocity", level: "green", detail: `Units averaging ${avgTimeMins || "<1"}min each` };
-}
-// ── Main API ───────────────────────────────────────────────────────────────
-/**
- * Compute the current progress score by evaluating all available signals.
- * Returns a composite score with individual signal details.
- */
-export function computeProgressScore() {
-    const signals = [
-        evaluateHealthTrend(),
-        evaluateErrorStreak(),
-        evaluateRecentErrors(),
-        evaluateArtifactProduction(),
-        evaluateDispatchVelocity(),
-    ];
-    // Overall level: worst of all signals
-    const level = signals.some(s => s.level === "red")
-        ? "red"
-        : signals.some(s => s.level === "yellow")
-            ? "yellow"
-            : "green";
-    // Build summary from the most important signals
-    const summary = buildSummary(level, signals);
+    const summary = level === "green"
+        ? "Progressing well"
+        : level === "yellow"
+            ? "Some issues detected"
+            : "Stuck or erroring";
     return { level, summary, signals };
 }
 /**
- * Compute progress score with additional context from the current unit.
+ * Compute progress score with additional context for dashboard display.
  */
 export function computeProgressScoreWithContext(context) {
     const base = computeProgressScore();
-    // Add retry signal if available
-    if (context.retryCount !== undefined && context.maxRetries !== undefined) {
-        const retrySignal = context.retryCount === 0
-            ? { name: "retry_count", level: "green", detail: "No retries" }
-            : context.retryCount <= 2
-                ? { name: "retry_count", level: "yellow", detail: `Retry ${context.retryCount}/${context.maxRetries}` }
-                : { name: "retry_count", level: "red", detail: `Retry ${context.retryCount}/${context.maxRetries} — looping` };
-        base.signals.push(retrySignal);
-        // Re-evaluate level
-        if (retrySignal.level === "red")
-            base.level = "red";
-        else if (retrySignal.level === "yellow" && base.level === "green")
-            base.level = "yellow";
+    if (context.sameUnitCount && context.sameUnitCount >= 3) {
+        base.signals.push({ kind: "negative", label: `Same unit dispatched ${context.sameUnitCount}× consecutively` });
+        base.level = escalateLevel(base.level, "red");
+        base.summary = "Stuck on same unit";
     }
-    // Build richer summary with context
-    base.summary = buildSummaryWithContext(base.level, base.signals, context);
-    return base;
-}
-// ── Formatting ─────────────────────────────────────────────────────────────
-function buildSummary(level, signals) {
-    switch (level) {
-        case "green":
-            return "Progressing well";
-        case "yellow": {
-            const issues = signals.filter(s => s.level === "yellow").map(s => s.detail);
-            return `Struggling — ${issues[0] ?? "minor issues detected"}`;
-        }
-        case "red": {
-            const issues = signals.filter(s => s.level === "red").map(s => s.detail);
-            return `Stuck — ${issues[0] ?? "critical issues detected"}`;
-        }
+    else if (context.sameUnitCount && context.sameUnitCount >= 2) {
+        base.signals.push({ kind: "negative", label: `Same unit dispatched ${context.sameUnitCount}×` });
+        base.level = escalateLevel(base.level, "yellow");
     }
-}
-function buildSummaryWithContext(level, signals, context) {
-    const unitLabel = context.currentUnitId
-        ? ` ${context.currentUnitId}`
-        : "";
-    const progressLabel = context.completedUnits !== undefined && context.totalUnits !== undefined
-        ? ` (${context.completedUnits} of ${context.totalUnits} done)`
-        : "";
-    switch (level) {
-        case "green":
-            return `Progressing well —${unitLabel}${progressLabel}`;
-        case "yellow": {
-            const issues = signals.filter(s => s.level === "yellow").map(s => s.detail);
-            const retryInfo = context.retryCount ? `, attempt ${context.retryCount}/${context.maxRetries}` : "";
-            return `Struggling —${unitLabel}${retryInfo}${progressLabel ? ` ${progressLabel}` : ""}, ${issues[0] ?? "issues detected"}`;
-        }
-        case "red": {
-            const issues = signals.filter(s => s.level === "red").map(s => s.detail);
-            return `Stuck —${unitLabel}${progressLabel ? ` ${progressLabel}` : ""}, ${issues[0] ?? "critical issues"}`;
-        }
+    if (context.recoveryCount && context.recoveryCount > 0) {
+        base.signals.push({ kind: "negative", label: `${context.recoveryCount} recovery attempts` });
+        base.level = escalateLevel(base.level, "yellow");
+    }
+    if (context.completedCount && context.completedCount > 0) {
+        base.signals.push({ kind: "positive", label: `${context.completedCount} units completed` });
     }
+    return base;
 }
 /**
- * Format progress score as a single-line traffic light for TUI display.
+ * Format a one-line progress indicator for dashboard/status display.
  */
 export function formatProgressLine(score) {
-    const icon = score.level === "green" ? "\uD83D\uDFE2"
-        : score.level === "yellow" ? "\uD83D\uDFE1"
-            : "\uD83D\uDD34";
+    const icon = score.level === "green" ? "●" : score.level === "yellow" ? "◐" : "○";
     return `${icon} ${score.summary}`;
 }
 /**
- * Format a detailed progress report showing all signals.
+ * Format a multi-line progress report.
  */
 export function formatProgressReport(score) {
-    const lines = [];
-    lines.push(formatProgressLine(score));
-    lines.push("");
-    lines.push("Signals:");
+    const lines = [formatProgressLine(score)];
     for (const signal of score.signals) {
-        const icon = signal.level === "green" ? "\u2705"
-            : signal.level === "yellow" ? "\u26A0\uFE0F"
-                : "\uD83D\uDED1";
-        lines.push(`  ${icon} ${signal.name}: ${signal.detail}`);
+        const prefix = signal.kind === "positive" ? "  ✓" : signal.kind === "negative" ? "  ✗" : "  ·";
+        lines.push(`${prefix} ${signal.label}`);
     }
     return lines.join("\n");
 }

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

@@ -8,12 +8,14 @@
  * Quick tasks live in `.gsd/quick/` and are tracked in STATE.md's
  * "Quick Tasks Completed" table.
  */
-import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync, unlinkSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { loadPrompt } from "./prompt-loader.js";
 import { gsdRoot } from "./paths.js";
-import { createGitService, runGit } from "./git-service.js";
-import { getErrorMessage } from "./error-utils.js";
+import { GitServiceImpl, runGit } from "./git-service.js";
+import { loadEffectiveGSDPreferences } from "./preferences.js";
+import { nativeHasStagedChanges } from "./native-git-bridge.js";
+let pendingQuickReturn = null;
 // ─── Quick Task Helpers ───────────────────────────────────────────────────────
 /**
  * Generate a URL-friendly slug from a description.
@@ -62,6 +64,71 @@ function ensureQuickDir(basePath, taskNum, slug) {
     mkdirSync(taskDir, { recursive: true });
     return taskDir;
 }
+function quickReturnStatePath(basePath) {
+    return join(gsdRoot(basePath), "runtime", "quick-return.json");
+}
+function persistPendingReturn(state) {
+    pendingQuickReturn = state;
+    mkdirSync(join(gsdRoot(state.basePath), "runtime"), { recursive: true });
+    writeFileSync(quickReturnStatePath(state.basePath), JSON.stringify(state) + "\n", "utf-8");
+}
+function readPendingReturn(basePath) {
+    if (pendingQuickReturn && pendingQuickReturn.basePath === basePath) {
+        return pendingQuickReturn;
+    }
+    try {
+        const raw = readFileSync(quickReturnStatePath(basePath), "utf-8");
+        const parsed = JSON.parse(raw);
+        if (typeof parsed.basePath === "string"
+            && typeof parsed.originalBranch === "string"
+            && typeof parsed.quickBranch === "string"
+            && typeof parsed.taskNum === "number"
+            && typeof parsed.slug === "string"
+            && typeof parsed.description === "string") {
+            pendingQuickReturn = parsed;
+            return pendingQuickReturn;
+        }
+    }
+    catch {
+        // No persisted quick-return state
+    }
+    return null;
+}
+function clearPendingReturn(basePath) {
+    if (pendingQuickReturn?.basePath === basePath) {
+        pendingQuickReturn = null;
+    }
+    rmSync(quickReturnStatePath(basePath), { force: true });
+}
+function hasStagedChanges(basePath) {
+    return nativeHasStagedChanges(basePath);
+}
+export function cleanupQuickBranch(basePath = process.cwd()) {
+    const state = readPendingReturn(basePath);
+    if (!state)
+        return false;
+    const repoPath = state.basePath;
+    const gitPrefs = loadEffectiveGSDPreferences()?.preferences?.git ?? {};
+    const git = new GitServiceImpl(repoPath, gitPrefs);
+    if (git.getCurrentBranch() === state.quickBranch) {
+        try {
+            git.autoCommit("quick-task", `Q${state.taskNum}`, []);
+        }
+        catch {
+            // Best-effort: quick work may already be committed.
+        }
+    }
+    if (git.getCurrentBranch() !== state.originalBranch) {
+        runGit(repoPath, ["checkout", state.originalBranch]);
+    }
+    runGit(repoPath, ["merge", "--squash", state.quickBranch]);
+    if (hasStagedChanges(repoPath)) {
+        runGit(repoPath, ["commit", "-m", `quick(Q${state.taskNum}): ${state.slug}`]);
+    }
+    runGit(repoPath, ["branch", "-D", state.quickBranch], { allowFailure: true });
+    clearPendingReturn(repoPath);
+    return true;
+}
 // ─── Main Handler ─────────────────────────────────────────────────────────────
 export async function handleQuick(args, ctx, pi) {
     const basePath = process.cwd();
@@ -84,32 +151,40 @@ export async function handleQuick(args, ctx, pi) {
     const taskDir = ensureQuickDir(basePath, taskNum, slug);
     const taskDirRel = `.gsd/quick/${taskNum}-${slug}`;
     const date = new Date().toISOString().split("T")[0];
-    // Create git branch for the quick task (unless isolation: none)
-    const git = createGitService(basePath);
+    // Create git branch for the quick task
+    const gitPrefs = loadEffectiveGSDPreferences()?.preferences?.git ?? {};
+    const git = new GitServiceImpl(basePath, gitPrefs);
     const branchName = `gsd/quick/${taskNum}-${slug}`;
-    const skipBranch = git.prefs.isolation === "none";
+    let originalBranch = git.getCurrentBranch();
     let branchCreated = false;
-    let originalBranch;
-    if (!skipBranch) {
-        try {
-            originalBranch = git.getCurrentBranch();
-            if (originalBranch !== branchName) {
-                // Auto-commit any dirty state before switching
-                try {
-                    git.autoCommit("quick-task", `Q${taskNum}`, []);
-                }
-                catch { /* nothing to commit — fine */ }
-                runGit(basePath, ["checkout", "-b", branchName]);
-                branchCreated = true;
+    try {
+        const current = originalBranch;
+        if (current !== branchName) {
+            // Auto-commit any dirty state before switching
+            try {
+                git.autoCommit("quick-task", `Q${taskNum}`, []);
             }
-        }
-        catch (err) {
-            // Branch creation failed — continue on current branch
-            const message = getErrorMessage(err);
-            ctx.ui.notify(`Could not create branch ${branchName}: ${message}. Working on current branch.`, "warning");
+            catch { /* nothing to commit — fine */ }
+            runGit(basePath, ["checkout", "-b", branchName]);
+            branchCreated = true;
         }
     }
+    catch (err) {
+        // Branch creation failed — continue on current branch
+        const message = err instanceof Error ? err.message : String(err);
+        ctx.ui.notify(`Could not create branch ${branchName}: ${message}. Working on current branch.`, "warning");
+    }
     const actualBranch = branchCreated ? branchName : git.getCurrentBranch();
+    if (actualBranch === branchName && originalBranch !== branchName) {
+        persistPendingReturn({
+            basePath,
+            originalBranch,
+            quickBranch: branchName,
+            taskNum,
+            slug,
+            description,
+        });
+    }
     // Notify user
     ctx.ui.notify(`Quick task ${taskNum}: ${description}\nDirectory: ${taskDirRel}\nBranch: ${actualBranch}`, "info");
     // Build and dispatch the quick task prompt
@@ -128,103 +203,4 @@ export async function handleQuick(args, ctx, pi) {
         content: prompt,
         display: false,
     }, { triggerTurn: true });
-    // Schedule branch merge-back after the quick task agent session ends.
-    // Without this, auto-mode resumes on the quick-task branch (#1269).
-    if (branchCreated && originalBranch) {
-        _pendingQuickBranchReturn = {
-            basePath,
-            originalBranch,
-            quickBranch: branchName,
-            taskNum,
-            slug,
-            description,
-        };
-        // Persist to disk so recovery works across session crashes (#1293).
-        persistPendingReturn(_pendingQuickBranchReturn, basePath);
-    }
-}
-/** Pending quick-task branch return — consumed by cleanupQuickBranch(). */
-let _pendingQuickBranchReturn = null;
-// ─── Disk Persistence ─────────────────────────────────────────────────────
-/** Path to the pending quick-task return file. */
-function pendingReturnPath(basePath) {
-    return join(gsdRoot(basePath), "runtime", "quick-return.json");
-}
-/** Write pending return state to disk. */
-function persistPendingReturn(state, basePath) {
-    const filePath = pendingReturnPath(basePath);
-    mkdirSync(join(gsdRoot(basePath), "runtime"), { recursive: true });
-    writeFileSync(filePath, JSON.stringify(state, null, 2) + "\n", "utf-8");
-}
-/** Remove pending return file from disk. */
-function clearPendingReturn(basePath) {
-    try {
-        unlinkSync(pendingReturnPath(basePath));
-    }
-    catch { /* already gone */ }
-}
-/** Load pending return from disk (cross-session recovery). */
-function loadPendingReturn(basePath) {
-    const filePath = pendingReturnPath(basePath);
-    if (!existsSync(filePath))
-        return null;
-    try {
-        return JSON.parse(readFileSync(filePath, "utf-8"));
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * Merge the quick-task branch back to the original branch and switch.
- * Called from the agent_end handler after a quick task completes.
- *
- * Checks both in-memory state (same session) and disk state (cross-session
- * recovery for crashed/interrupted sessions).
- *
- * Returns true if a branch return was performed.
- */
-export function cleanupQuickBranch() {
-    // Prefer in-memory state; fall back to disk for cross-session recovery
-    let state = _pendingQuickBranchReturn;
-    if (!state) {
-        // Try loading from disk — handles the case where the session that
-        // started the quick task crashed before agent_end could run (#1293).
-        const basePath = process.cwd();
-        state = loadPendingReturn(basePath);
-    }
-    if (!state)
-        return false;
-    _pendingQuickBranchReturn = null;
-    const { basePath, originalBranch, quickBranch, taskNum, slug, description } = state;
-    try {
-        // Auto-commit any remaining work
-        try {
-            runGit(basePath, ["add", "-A"]);
-        }
-        catch { }
-        try {
-            runGit(basePath, ["commit", "-m", `quick(Q${taskNum}): ${slug}`]);
-        }
-        catch { }
-        // Switch back and merge
-        runGit(basePath, ["checkout", originalBranch]);
-        try {
-            runGit(basePath, ["merge", "--squash", quickBranch]);
-            runGit(basePath, ["commit", "-m", `quick(Q${taskNum}): ${description.slice(0, 72)}`]);
-        }
-        catch { /* merge conflict or nothing — non-fatal */ }
-        // Clean up quick branch
-        try {
-            runGit(basePath, ["branch", "-D", quickBranch]);
-        }
-        catch { }
-        // Clean up disk state
-        clearPendingReturn(basePath);
-        return true;
-    }
-    catch {
-        // Cleanup failed — leave disk state for next attempt
-        return false;
-    }
 }

package/dist/resources/extensions/gsd/session-lock.js

@@ -129,6 +129,18 @@ function ensureExitHandler(gsdDir) {
  */
 export function acquireSessionLock(basePath) {
     const lp = lockPath(basePath);
+    // Re-entrant acquire on the same path: release our current OS lock first so
+    // proper-lockfile clears its update timer before we acquire a fresh lock.
+    if (_releaseFunction && _lockedPath === basePath) {
+        try {
+            _releaseFunction();
+        }
+        catch { /* may already be released */ }
+        _releaseFunction = null;
+        _lockedPath = null;
+        _lockPid = 0;
+        _lockCompromised = false;
+    }
     // Ensure the directory exists
     mkdirSync(dirname(lp), { recursive: true });
     // Clean up numbered lock file variants from cloud sync conflicts (#1315)
@@ -206,6 +218,7 @@ export function acquireSessionLock(basePath) {
                 _releaseFunction = release;
                 _lockedPath = basePath;
                 _lockPid = process.pid;
+                _lockCompromised = false;
                 // Safety net — uses centralized handler to avoid double-registration
                 ensureExitHandler(gsdDir);
                 atomicWriteSync(lp, JSON.stringify(lockData, null, 2));

package/dist/resources/extensions/gsd/templates/preferences.md

@@ -30,6 +30,7 @@ token_profile:
 phases:
   skip_research:
   skip_reassess:
+  reassess_after_slice:
   skip_slice_research:
 dynamic_routing:
   enabled: