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

package/src/resources/extensions/gsd/post-unit-hooks.ts

@@ -14,8 +14,6 @@ import type {
 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 ──────────────────────────────────────────────────────
 
@@ -150,7 +148,7 @@ function dequeueNextHook(basePath: string): HookDispatchResult | null {
     };
 
     // 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 ?? "")
@@ -209,14 +207,16 @@ function handleHookCompletion(basePath: string): HookDispatchResult | null {
  *   - Milestone-level (M001):    .gsd/M001/{artifact}
  */
 export function resolveHookArtifactPath(basePath: string, unitId: string, artifactName: string): string {
-  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);
 }
 
 // ═══════════════════════════════════════════════════════════════════════════
@@ -252,7 +252,7 @@ export function runPreDispatchHooks(
     return { action: "proceed", prompt, firedHooks: [] };
   }
 
-  const { milestone: mid, slice: sid, task: tid } = parseUnitId(unitId);
+  const [mid, sid, tid] = unitId.split("/");
   const substitute = (text: string): string =>
     text
       .replace(/\{milestoneId\}/g, mid ?? "")
@@ -310,7 +310,7 @@ export function runPreDispatchHooks(
 const HOOK_STATE_FILE = "hook-state.json";
 
 function hookStatePath(basePath: string): string {
-  return join(gsdRoot(basePath), HOOK_STATE_FILE);
+  return join(basePath, ".gsd", HOOK_STATE_FILE);
 }
 
 /**
@@ -323,7 +323,7 @@ export function persistHookState(basePath: string): void {
     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");
   } catch {
@@ -465,7 +465,7 @@ export function triggerHookManually(
   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/src/resources/extensions/gsd/progress-score.ts

@@ -28,246 +28,111 @@ export interface ProgressScore {
 }
 
 export interface ProgressSignal {
-  name: string;
-  level: ProgressLevel;
-  detail: string;
-}
-
-// ── Signal Evaluators ──────────────────────────────────────────────────────
-
-function evaluateHealthTrend(): ProgressSignal {
-  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" };
-  }
+  kind: "positive" | "negative" | "neutral";
+  label: string;
 }
 
-function evaluateErrorStreak(): ProgressSignal {
-  const streak = getConsecutiveErrorUnits();
-
-  if (streak === 0) {
-    return { name: "error_streak", level: "green", detail: "No consecutive errors" };
-  }
-  if (streak <= 2) {
-    return { name: "error_streak", level: "yellow", detail: `${streak} consecutive error unit(s)` };
-  }
-  return { name: "error_streak", level: "red", detail: `${streak} consecutive error units` };
+function escalateLevel(level: ProgressLevel, next: ProgressLevel): ProgressLevel {
+  const ranks: Record<ProgressLevel, number> = {
+    green: 0,
+    yellow: 1,
+    red: 2,
+  };
+  return ranks[next] > ranks[level] ? next : level;
 }
 
-function evaluateRecentErrors(): ProgressSignal {
-  const history = getHealthHistory();
-  if (history.length === 0) {
-    return { name: "recent_errors", level: "green", detail: "No health data yet" };
-  }
-
-  const latest = history[history.length - 1]!;
+// ── Public API ──────────────────────────────────────────────────────────────
 
-  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)` };
-}
+/**
+ * Compute the current progress score from health signals.
+ */
+export function computeProgressScore(): ProgressScore {
+  const signals: ProgressSignal[] = [];
+  let level: ProgressLevel = "green";
 
-function evaluateArtifactProduction(): ProgressSignal {
-  const history = getHealthHistory();
-  if (history.length < 2) {
-    return { name: "artifact_production", level: "green", detail: "Insufficient data" };
+  // 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");
   }
 
-  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" };
+  // Check health trend
+  const trend = getHealthTrend();
+  if (trend === "degrading") {
+    signals.push({ kind: "negative", label: "Health trend declining" });
+    level = escalateLevel(level, "yellow");
+  } else if (trend === "improving") {
+    signals.push({ kind: "positive", label: "Health trend improving" });
+  } else if (trend === "stable") {
+    signals.push({ kind: "neutral", label: "Health trend stable" });
   }
 
-  return { name: "artifact_production", level: "green", detail: `${totalFixes} total fixes applied` };
-}
-
-function evaluateDispatchVelocity(): ProgressSignal {
+  // Check recent history
   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: number[] = [];
-  for (let i = 1; i < recent.length; i++) {
-    timeDiffs.push(recent[i]!.timestamp - recent[i - 1]!.timestamp);
-  }
-
-  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` };
+  if (history.length === 0) {
+    signals.push({ kind: "neutral", label: "No health data yet" });
   }
 
-  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(): ProgressScore {
-  const signals: ProgressSignal[] = [
-    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: {
-  currentUnitType?: string;
-  currentUnitId?: string;
-  completedUnits?: number;
-  totalUnits?: number;
-  retryCount?: number;
-  maxRetries?: number;
+  sameUnitCount?: number;
+  recoveryCount?: number;
+  completedCount?: number;
 }): ProgressScore {
   const base = computeProgressScore();
 
-  // Add retry signal if available
-  if (context.retryCount !== undefined && context.maxRetries !== undefined) {
-    const retrySignal: ProgressSignal = 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";
+  } else if (context.sameUnitCount && context.sameUnitCount >= 2) {
+    base.signals.push({ kind: "negative", label: `Same unit dispatched ${context.sameUnitCount}×` });
+    base.level = escalateLevel(base.level, "yellow");
   }
 
-  // Build richer summary with context
-  base.summary = buildSummaryWithContext(base.level, base.signals, context);
-
-  return base;
-}
-
-// ── Formatting ─────────────────────────────────────────────────────────────
-
-function buildSummary(level: ProgressLevel, signals: ProgressSignal[]): string {
-  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"}`;
-    }
+  if (context.recoveryCount && context.recoveryCount > 0) {
+    base.signals.push({ kind: "negative", label: `${context.recoveryCount} recovery attempts` });
+    base.level = escalateLevel(base.level, "yellow");
   }
-}
-
-function buildSummaryWithContext(
-  level: ProgressLevel,
-  signals: ProgressSignal[],
-  context: {
-    currentUnitType?: string;
-    currentUnitId?: string;
-    completedUnits?: number;
-    totalUnits?: number;
-    retryCount?: number;
-    maxRetries?: number;
-  },
-): string {
-  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.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: ProgressScore): string {
-  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: ProgressScore): string {
-  const lines: string[] = [];
-
-  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/src/resources/extensions/gsd/quick.ts

@@ -10,12 +10,24 @@
  */
 
 import type { ExtensionAPI, ExtensionCommandContext } from "@gsd/pi-coding-agent";
-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";
+
+interface QuickReturnState {
+  basePath: string;
+  originalBranch: string;
+  quickBranch: string;
+  taskNum: number;
+  slug: string;
+  description: string;
+}
+
+let pendingQuickReturn: QuickReturnState | null = null;
 
 // ─── Quick Task Helpers ───────────────────────────────────────────────────────
 
@@ -65,6 +77,84 @@ function ensureQuickDir(basePath: string, taskNum: number, slug: string): string
   return taskDir;
 }
 
+function quickReturnStatePath(basePath: string): string {
+  return join(gsdRoot(basePath), "runtime", "quick-return.json");
+}
+
+function persistPendingReturn(state: QuickReturnState): void {
+  pendingQuickReturn = state;
+  mkdirSync(join(gsdRoot(state.basePath), "runtime"), { recursive: true });
+  writeFileSync(quickReturnStatePath(state.basePath), JSON.stringify(state) + "\n", "utf-8");
+}
+
+function readPendingReturn(basePath: string): QuickReturnState | null {
+  if (pendingQuickReturn && pendingQuickReturn.basePath === basePath) {
+    return pendingQuickReturn;
+  }
+
+  try {
+    const raw = readFileSync(quickReturnStatePath(basePath), "utf-8");
+    const parsed = JSON.parse(raw) as Partial<QuickReturnState>;
+    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 as QuickReturnState;
+      return pendingQuickReturn;
+    }
+  } catch {
+    // No persisted quick-return state
+  }
+
+  return null;
+}
+
+function clearPendingReturn(basePath: string): void {
+  if (pendingQuickReturn?.basePath === basePath) {
+    pendingQuickReturn = null;
+  }
+  rmSync(quickReturnStatePath(basePath), { force: true });
+}
+
+function hasStagedChanges(basePath: string): boolean {
+  return nativeHasStagedChanges(basePath);
+}
+
+export function cleanupQuickBranch(basePath = process.cwd()): boolean {
+  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(
@@ -102,33 +192,41 @@ export async function handleQuick(
   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: string | undefined;
-  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;
-      }
-    } 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");
+  try {
+    const current = originalBranch;
+    if (current !== 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;
     }
+  } 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(
@@ -156,106 +254,4 @@ export async function handleQuick(
     },
     { 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: {
-  basePath: string;
-  originalBranch: string;
-  quickBranch: string;
-  taskNum: number;
-  slug: string;
-  description: string;
-} | null = null;
-
-// ─── Disk Persistence ─────────────────────────────────────────────────────
-
-/** Path to the pending quick-task return file. */
-function pendingReturnPath(basePath: string): string {
-  return join(gsdRoot(basePath), "runtime", "quick-return.json");
-}
-
-/** Write pending return state to disk. */
-function persistPendingReturn(state: NonNullable<typeof _pendingQuickBranchReturn>, basePath: string): void {
-  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: string): void {
-  try { unlinkSync(pendingReturnPath(basePath)); } catch { /* already gone */ }
-}
-
-/** Load pending return from disk (cross-session recovery). */
-function loadPendingReturn(basePath: string): NonNullable<typeof _pendingQuickBranchReturn> | null {
-  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(): boolean {
-  // 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;
-  }
 }