@10et/cli 1.0.0

package/packages/pi/extensions/session.ts

@@ -0,0 +1,684 @@
+/**
+ * JFL Session Extension
+ *
+ * Pi-native session lifecycle via Context Hub API.
+ * Calls POST /api/session/init on start and POST /api/session/end on shutdown.
+ * Hub handles sync, doctor, branch creation — single source of truth.
+ * Pi only manages the auto-commit daemon locally (needs a detached process).
+ *
+ * AGENT MODE: When JFL_AGENT_MODE=1 or --print is used (PP agent runs),
+ * skip ALL session branching. PP agents work in isolated /tmp worktrees —
+ * they must NOT touch the main repo's git state.
+ *
+ * @purpose Pi session lifecycle — Hub API for init/end, local auto-commit daemon
+ */
+
+import { execSync, spawn, exec } from "child_process"
+import { promisify } from "util"
+import { existsSync, readFileSync, writeFileSync, unlinkSync, statSync } from "fs"
+import { join } from "path"
+import type { PiContext, JflConfig } from "./types.js"
+import { hubUrl, authToken } from "./map-bridge.js"
+
+const execAsync = promisify(exec)
+
+let autoCommitProcess: ReturnType<typeof spawn> | null = null
+let sessionBranch = ""
+let isAgentMode = false
+
+/**
+ * Detect if we're running in agent/ephemeral mode where session branching
+ * should be completely skipped. This happens when:
+ * - JFL_AGENT_MODE=1 env var is set (PP agent runs)
+ * - PI_PRINT_MODE=1 (set by Pi core in --print mode)
+ * - Process was spawned by PP (JFL_PP_SPAWNED=1)
+ */
+function detectAgentMode(): boolean {
+  return (
+    process.env.JFL_AGENT_MODE === "1" ||
+    process.env.JFL_PP_SPAWNED === "1" ||
+    process.env.PI_PRINT_MODE === "1" ||
+    process.argv.includes("--print") ||
+    process.argv.includes("-p")
+  )
+}
+
+/**
+ * Get working branch from .jfl/config.json or default to "main"
+ */
+function getWorkingBranch(root: string): string {
+  const configPath = join(root, ".jfl", "config.json")
+  if (existsSync(configPath)) {
+    try {
+      const cfg = JSON.parse(readFileSync(configPath, "utf-8"))
+      if (cfg.working_branch) return cfg.working_branch
+    } catch {}
+  }
+  return "main"
+}
+
+/**
+ * Merge a stale session branch to the working branch.
+ * Called during onInit when we find ourselves on an old session branch,
+ * to prevent data loss from abandoned branches.
+ *
+ * Returns true if merge succeeded (or branch had no unique work).
+ */
+function mergeStaleSessionBranch(
+  root: string,
+  staleBranch: string,
+  workingBranch: string,
+  ctx: { log: (msg: string, level?: "debug" | "info" | "warn" | "error") => void; ui: { notify: (msg: string, opts?: any) => void } },
+): boolean {
+  try {
+    // Check if the stale branch has any commits not in working branch
+    const uniqueCommits = execSync(
+      `git log --oneline "${workingBranch}".."${staleBranch}" 2>/dev/null | wc -l`,
+      { cwd: root, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] },
+    ).trim()
+
+    if (uniqueCommits === "0") {
+      // No unique work — safe to just switch away
+      ctx.log(`Stale branch ${staleBranch} has no unique commits, switching to ${workingBranch}`, "debug")
+      return true
+    }
+
+    ctx.log(`Stale branch ${staleBranch} has ${uniqueCommits} unique commits — merging to ${workingBranch}`, "info")
+    ctx.ui.notify(`⚠ Recovering ${uniqueCommits} commits from stale session ${staleBranch}`, { level: "warn" })
+
+    // Commit any dirty state first
+    try {
+      const status = execSync("git status --porcelain", { cwd: root, encoding: "utf-8", timeout: 5000, stdio: ["pipe", "pipe", "pipe"] }).trim()
+      if (status) {
+        execSync("git add -A && git commit -m 'auto: save before stale branch merge' --no-verify", {
+          cwd: root, timeout: 10000, stdio: ["pipe", "pipe", "pipe"],
+        })
+      }
+    } catch {}
+
+    // Switch to working branch
+    execSync(`git checkout "${workingBranch}"`, { cwd: root, timeout: 10000, stdio: ["pipe", "pipe", "pipe"] })
+
+    // Merge stale branch with auto-resolve for .jfl conflicts
+    try {
+      execSync(`git merge "${staleBranch}" --no-edit -X ours`, { cwd: root, timeout: 15000, stdio: ["pipe", "pipe", "pipe"] })
+      ctx.ui.notify(`✓ Recovered stale session ${staleBranch} → ${workingBranch}`, { level: "info" })
+
+      // Clean up the stale branch
+      try {
+        execSync(`git branch -d "${staleBranch}"`, { cwd: root, timeout: 5000, stdio: ["pipe", "pipe", "pipe"] })
+      } catch {}
+
+      return true
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err)
+      if (msg.includes("CONFLICT") || msg.includes("conflict")) {
+        // Abort merge, stay on working branch, leave stale branch for manual resolution
+        try { execSync("git merge --abort", { cwd: root, timeout: 5000, stdio: ["pipe", "pipe", "pipe"] }) } catch {}
+        ctx.ui.notify(`⚠ Merge conflict recovering ${staleBranch} — branch preserved for manual merge`, { level: "warn" })
+        return true // Still switch to working branch, just don't delete the old one
+      }
+      throw err
+    }
+  } catch (err) {
+    ctx.log(`Failed to merge stale branch ${staleBranch}: ${err}`, "warn")
+    return false
+  }
+}
+
+/**
+ * Acquire a file lock for session init to prevent concurrent sessions
+ * from racing on branch creation. Returns a release function.
+ */
+function acquireSessionLock(root: string): () => void {
+  const lockFile = join(root, ".jfl", ".session-init.lock")
+  const maxWait = 15000
+  const start = Date.now()
+
+  // Wait for existing lock to release
+  while (existsSync(lockFile) && Date.now() - start < maxWait) {
+    try {
+      const stat = statSync(lockFile)
+      // Stale lock (older than 30s) — break it
+      if (Date.now() - stat.mtimeMs > 30000) {
+        try { unlinkSync(lockFile) } catch {}
+        break
+      }
+    } catch { break }
+    // Busy-wait (sync context, can't await)
+    execSync("sleep 0.2", { stdio: "ignore" })
+  }
+
+  // Acquire
+  try {
+    writeFileSync(lockFile, `${process.pid}:${Date.now()}`)
+  } catch {}
+
+  return () => { try { unlinkSync(lockFile) } catch {} }
+}
+
+/**
+ * Create a session branch locally without the Hub.
+ * Parity with scripts/session/session-init.sh:
+ * 1. Acquire file lock to prevent concurrent session races
+ * 2. If on a stale session branch, MERGE it first (prevent data loss!)
+ * 3. Commit or stash remaining dirty state
+ * 4. Create new session branch from clean base
+ * 5. Pop stash if needed
+ * 6. Release lock
+ */
+function createSessionBranchLocally(root: string, ctx: { log: (msg: string, level?: "debug" | "info" | "warn" | "error") => void; ui: { notify: (msg: string, opts?: any) => void } }): string {
+  // Acquire lock to prevent concurrent session init races
+  const releaseLock = acquireSessionLock(root)
+
+  try {
+    return _createSessionBranchLocally(root, ctx)
+  } finally {
+    releaseLock()
+  }
+}
+
+function _createSessionBranchLocally(root: string, ctx: { log: (msg: string, level?: "debug" | "info" | "warn" | "error") => void; ui: { notify: (msg: string, opts?: any) => void } }): string {
+  // Generate session branch name
+  const user = (() => {
+    try {
+      return execSync("git config user.name", { cwd: root, stdio: ["pipe", "pipe", "pipe"] })
+        .toString().trim().replace(/\s+/g, "-").toLowerCase().replace(/[^a-z0-9-]/g, "").slice(0, 30) || "user"
+    } catch { return "user" }
+  })()
+  const now = new Date()
+  const dateStr = now.toISOString().slice(0, 10).replace(/-/g, "")
+  const timeStr = now.toISOString().slice(11, 16).replace(":", "")
+  const randomId = Math.random().toString(16).slice(2, 8)
+  const branchName = `session-${user}-${dateStr}-${timeStr}-${randomId}`
+
+  const workingBranch = getWorkingBranch(root)
+
+  // Step 1: If on a stale session branch, MERGE it to working branch first
+  const currentBranch = getCurrentBranch(root)
+  if (currentBranch.startsWith("session-")) {
+    ctx.log(`Found stale session branch ${currentBranch} — merging before creating new session`, "info")
+    mergeStaleSessionBranch(root, currentBranch, workingBranch, ctx)
+    // After merge, we should be on workingBranch
+  }
+
+  // Step 2: Commit or stash dirty state so checkout doesn't fail
+  let stashed = false
+  try {
+    const status = execSync("git status --porcelain", { cwd: root, timeout: 5000, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim()
+    if (status) {
+      try {
+        execSync("git add -A && git commit -m 'auto: session-init save' --no-verify", { cwd: root, timeout: 10000, stdio: ["pipe", "pipe", "pipe"] })
+      } catch {
+        // Commit failed — stash instead
+        try {
+          execSync("git stash push -m 'jfl-session-init-stash' --include-untracked", { cwd: root, timeout: 10000, stdio: ["pipe", "pipe", "pipe"] })
+          stashed = true
+        } catch {}
+      }
+    }
+  } catch {}
+
+  // Step 3: Ensure we're on working branch before creating session branch
+  const nowBranch = getCurrentBranch(root)
+  if (nowBranch !== workingBranch) {
+    try {
+      execSync(`git checkout "${workingBranch}"`, { cwd: root, timeout: 10000, stdio: ["pipe", "pipe", "pipe"] })
+    } catch {
+      ctx.log(`Could not switch to ${workingBranch} — branching from ${nowBranch}`, "warn")
+    }
+  }
+
+  // Step 4: Create new session branch
+  let finalBranch = branchName
+  try {
+    execSync(`git checkout -b "${branchName}"`, { cwd: root, stdio: ["pipe", "pipe", "pipe"] })
+    ctx.ui.notify(`Session branch: ${branchName}`, { level: "info" })
+  } catch {
+    // Branch name collision — retry with longer ID
+    const fallbackId = Math.random().toString(16).slice(2, 14)
+    const fallbackBranch = `session-${user}-${dateStr}-${timeStr}-${fallbackId}`
+    try {
+      execSync(`git checkout -b "${fallbackBranch}"`, { cwd: root, stdio: ["pipe", "pipe", "pipe"] })
+      finalBranch = fallbackBranch
+    } catch {
+      // Give up — use current branch
+      finalBranch = getCurrentBranch(root)
+      ctx.log(`Could not create session branch — using ${finalBranch}`, "warn")
+      ctx.ui.notify(`Branch creation failed — using ${finalBranch}`, { level: "warn" })
+    }
+  }
+
+  // Step 5: Pop stash if we stashed
+  if (stashed) {
+    try {
+      execSync("git stash pop", { cwd: root, timeout: 10000, stdio: ["pipe", "pipe", "pipe"] })
+    } catch {
+      ctx.log("Could not pop stash — run 'git stash pop' manually", "warn")
+    }
+  }
+
+  // Save session info
+  try {
+    const jflDir = join(root, ".jfl")
+    writeFileSync(join(jflDir, "current-session-branch.txt"), finalBranch)
+  } catch {}
+
+  return finalBranch
+}
+
+function findScript(root: string, scriptName: string): string | null {
+  const candidates = [
+    join(root, "scripts", "session", scriptName),
+    join(root, "scripts", scriptName),
+  ]
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) return candidate
+  }
+  return null
+}
+
+export async function setupSession(ctx: PiContext, _config: JflConfig): Promise<void> {
+  const root = ctx.session.projectRoot
+
+  // ── Agent mode detection ─────────────────────────────────────────────
+  // PP agents work in isolated /tmp worktrees. They must NOT create session
+  // branches or do any git operations in the main repo.
+  isAgentMode = detectAgentMode()
+  if (isAgentMode) {
+    sessionBranch = getCurrentBranch(root)
+    ctx.log(`Agent mode detected — skipping session branching (on ${sessionBranch})`, "info")
+    return
+  }
+
+  // ── Delegate to session-init.sh ──────────────────────────────────────
+  // The shell script is the source of truth for session initialization.
+  // It handles: sync, doctor, crash recovery, concurrent session detection,
+  // worktree creation (when multiple sessions), direct branch mode (single
+  // session), and auto-commit startup. We parse its output for the branch
+  // name and worktree path.
+  const sessionInitScript = findScript(root, "session-init.sh")
+
+  if (sessionInitScript) {
+    try {
+      const output = execSync(`bash "${sessionInitScript}"`, {
+        cwd: root,
+        timeout: 60000,
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"],
+        env: { ...process.env, JFL_REPO_DIR: root },
+      })
+
+      ctx.log(`session-init.sh output:\n${output}`, "debug")
+
+      // Parse branch from saved file (most reliable)
+      try {
+        sessionBranch = readFileSync(join(root, ".jfl", "current-session-branch.txt"), "utf-8").trim()
+      } catch {
+        // Fallback: parse from git
+        sessionBranch = getCurrentBranch(root)
+      }
+
+      // Check if worktree was created
+      try {
+        const worktreePath = readFileSync(join(root, ".jfl", "current-worktree.txt"), "utf-8").trim()
+        if (worktreePath && worktreePath !== "direct" && existsSync(worktreePath)) {
+          ctx.log(`Session using worktree: ${worktreePath}`, "info")
+          ctx.ui.notify(`Session in worktree: ${worktreePath}`, { level: "info" })
+        }
+      } catch {}
+
+      // Log any warnings from output
+      const lines = output.split("\n")
+      for (const line of lines) {
+        if (line.includes("⚠") || line.includes("WARNING")) {
+          ctx.log(line.trim(), "warn")
+        }
+      }
+
+      ctx.ui.notify(`Session branch: ${sessionBranch}`, { level: "info" })
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err)
+      ctx.log(`session-init.sh failed: ${msg}`, "warn")
+      ctx.ui.notify(`Session init script failed — falling back to local branch`, { level: "warn" })
+
+      // Fallback: create branch locally (old behavior)
+      sessionBranch = createSessionBranchLocally(root, ctx)
+    }
+  } else {
+    // No session-init.sh found — use Hub API or local fallback
+    ctx.log("No session-init.sh found — using Hub API", "debug")
+
+    try {
+      const resp = await fetch(`${hubUrl}/api/session/init`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...(authToken ? { Authorization: `Bearer ${authToken}` } : {}),
+        },
+        body: JSON.stringify({ runtime: "pi" }),
+        signal: AbortSignal.timeout(30000),
+      })
+
+      if (resp.ok) {
+        const data = await resp.json() as { branch?: string; syncOk?: boolean; warnings?: string[]; doctor?: { errors: number; warnings: number } }
+        if (data.warnings?.length) {
+          for (const w of data.warnings) ctx.log(w, "warn")
+        }
+        if (data.doctor?.errors) {
+          ctx.ui.notify(`Doctor: ${data.doctor.errors} errors`, { level: "warn" })
+        }
+
+        const hubBranch = data.branch ?? ""
+        if (hubBranch.startsWith("session-")) {
+          sessionBranch = hubBranch
+          ctx.log(`Session init via Hub: branch=${sessionBranch}, sync=${data.syncOk}`, "debug")
+        } else {
+          ctx.log(`Hub returned non-session branch "${hubBranch}" — creating locally`, "warn")
+          sessionBranch = createSessionBranchLocally(root, ctx)
+        }
+      } else {
+        sessionBranch = createSessionBranchLocally(root, ctx)
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err)
+      ctx.log(`Hub unavailable: ${msg}`, "warn")
+      sessionBranch = createSessionBranchLocally(root, ctx)
+    }
+  }
+
+  // Ensure Hub is running (async, don't block session start)
+  try {
+    fetch(`${hubUrl}/health`, { signal: AbortSignal.timeout(3000) })
+      .catch(() => {
+        // Hub not running — try to start it
+        const hubScript = findScript(root, "context-hub-ensure.sh")
+        if (hubScript) {
+          spawn("bash", [hubScript], { cwd: root, detached: true, stdio: "ignore" }).unref()
+        }
+      })
+  } catch {}
+
+  // Start auto-commit daemon if session-init.sh didn't already
+  // (check for running process via PID file)
+  const pidFile = join(root, ".jfl", "auto-commit.pid")
+  let autoCommitRunning = false
+  if (existsSync(pidFile)) {
+    try {
+      const pid = parseInt(readFileSync(pidFile, "utf-8").trim())
+      if (pid > 0) {
+        process.kill(pid, 0) // Check if alive (throws if dead)
+        autoCommitRunning = true
+      }
+    } catch {}
+  }
+
+  if (!autoCommitRunning) {
+    const autoCommitScript = findScript(root, "auto-commit.sh")
+    if (autoCommitScript) {
+      autoCommitProcess = spawn("bash", [autoCommitScript, "start", "120"], {
+        cwd: root,
+        detached: true,
+        stdio: "ignore",
+      })
+      autoCommitProcess.unref()
+      ctx.log("Auto-commit daemon started (120s interval)", "debug")
+    }
+  }
+
+  ctx.emit("hook:session-start", {
+    session: ctx.session.id,
+    branch: sessionBranch,
+    projectRoot: root,
+    ts: new Date().toISOString(),
+  })
+}
+
+export function getSessionBranch(): string {
+  return sessionBranch
+}
+
+export async function pivot(ctx: PiContext, summary?: string): Promise<{
+  ok: boolean
+  pivotNumber: number
+  committed: boolean
+  commitHash: string | null
+  filesChanged: number
+  indexed: boolean
+}> {
+  const root = ctx.session.projectRoot
+
+  try {
+    const resp = await fetch(`${hubUrl}/api/session/pivot`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...(authToken ? { Authorization: `Bearer ${authToken}` } : {}),
+      },
+      body: JSON.stringify({ summary }),
+      signal: AbortSignal.timeout(30000),
+    })
+
+    if (resp.ok) {
+      const data = await resp.json() as any
+      ctx.emit("hook:session-pivot", {
+        session: ctx.session.id,
+        branch: sessionBranch,
+        pivotNumber: data.pivotNumber,
+        summary: summary || "",
+        ts: new Date().toISOString(),
+      })
+      ctx.log(`Pivot #${data.pivotNumber} via Hub`, "debug")
+      return data
+    }
+  } catch {
+    ctx.log("Hub unavailable for pivot, falling back to CLI", "debug")
+  }
+
+  // Fallback: shell out to jfl pivot
+  try {
+    const result = execSync(
+      `jfl pivot --json${summary ? ` --summary "${summary.replace(/"/g, '\\"')}"` : ""}`,
+      { cwd: root, encoding: "utf-8", timeout: 30000, stdio: ["pipe", "pipe", "pipe"] },
+    )
+    const parsed = JSON.parse(result)
+    ctx.emit("hook:session-pivot", {
+      session: ctx.session.id,
+      branch: sessionBranch,
+      pivotNumber: parsed.pivotNumber,
+      summary: summary || "",
+      ts: new Date().toISOString(),
+    })
+    return parsed
+  } catch (err) {
+    ctx.log(`Pivot fallback failed: ${err}`, "warn")
+    return { ok: false, pivotNumber: 0, committed: false, commitHash: null, filesChanged: 0, indexed: false }
+  }
+}
+
+export async function onShutdown(ctx: PiContext): Promise<void> {
+  const root = ctx.session.projectRoot
+  const branch = getSessionBranch() || getCurrentBranch(root)
+  const t0 = Date.now()
+
+  ctx.ui.notify("Ending session…", { level: "info" })
+
+  // ── Agent mode: skip all git operations ──────────────────────────────
+  if (isAgentMode) {
+    ctx.log("Agent mode — skipping session cleanup (no branching was done)", "debug")
+    ctx.emit("hook:session-end", { session: ctx.session.id, branch, ts: new Date().toISOString() })
+    return
+  }
+
+  // ── PHASE 1: Fire non-blocking tasks immediately ─────────────────────
+  // These run in parallel with the sequential git ops below.
+  // Using async I/O so they actually progress while git work happens.
+
+  // 1a. Hub API end (fire-and-forget, 5s cap)
+  const hubP = fetch(`${hubUrl}/api/session/end`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      ...(authToken ? { Authorization: `Bearer ${authToken}` } : {}),
+    },
+    body: JSON.stringify({ runtime: "pi" }),
+    signal: AbortSignal.timeout(5000),
+  }).then(() => { ctx.log("Hub session closed", "debug") })
+    .catch(() => { ctx.log("Hub session end failed", "debug") })
+
+  // 1b. Synopsis generation (read-only, safe to run during git ops)
+  const synopsisP = execAsync("jfl synopsis 4 2>/dev/null || true", { cwd: root, timeout: 10000 })
+    .then(r => r.stdout.trim())
+    .catch(() => "")
+
+  // 1c. Memory indexing (read-only index build, safe to run in parallel)
+  const memoryP = execAsync("jfl memory-index 2>/dev/null || true", { cwd: root, timeout: 15000 })
+    .then(() => { ctx.log("Memory indexed", "debug") })
+    .catch(() => { ctx.log("Memory index skipped", "debug") })
+
+  // ── PHASE 2: Sequential git ops (critical path) ─────────────────────
+  // These MUST be ordered: commit → merge → push
+  // Using async exec so parallel tasks can progress between steps.
+
+  // 2a. Journal check
+  const journalPath = join(root, ".jfl", "journal", `${branch}.jsonl`)
+  const hasJournal = existsSync(journalPath) && readFileSync(journalPath, "utf-8").trim().length > 0
+  if (!hasJournal) {
+    ctx.ui.notify(
+      "⚠️  No journal entry for this session. Context will be lost.\n" +
+      `   File: .jfl/journal/${branch}.jsonl`,
+      { level: "warn" }
+    )
+  }
+
+  // 2b. Kill auto-commit daemon
+  if (autoCommitProcess) {
+    try { autoCommitProcess.kill() } catch {}
+    autoCommitProcess = null
+  }
+
+  // 2c. Auto-commit any uncommitted changes (async — doesn't block event loop)
+  try {
+    const status = (await execAsync("git status --porcelain", { cwd: root, timeout: 3000 })).stdout.trim()
+    if (status) {
+      await execAsync("git add -A && git commit -m 'auto: session-end save' --no-verify", { cwd: root, timeout: 5000 })
+      ctx.ui.notify("  ✓ Changes saved", { level: "info" })
+    }
+  } catch {}
+
+  // 2d. Merge session branch
+  let mergeOk = false
+  let workingBranch = "main"
+
+  if (branch.startsWith("session-")) {
+    try {
+      workingBranch = getWorkingBranch(root)
+
+      // Remove stale lock files
+      const lockFile = join(root, ".git", "index.lock")
+      if (existsSync(lockFile)) {
+        try { unlinkSync(lockFile) } catch {}
+      }
+
+      // Ensure we're on our session branch
+      const currentGitBranch = getCurrentBranch(root)
+      if (currentGitBranch !== branch) {
+        try {
+          await execAsync(`git checkout "${branch}"`, { cwd: root, timeout: 10000 })
+          ctx.log(`Recovered session branch from ${currentGitBranch}`, "info")
+        } catch {
+          ctx.log(`Cannot checkout ${branch} — attempting merge anyway`, "warn")
+        }
+      }
+
+      // Commit any remaining dirty state
+      try {
+        await execAsync("git add -A && git commit -m 'session: auto-commit before merge' --no-verify", { cwd: root, timeout: 10000 })
+      } catch {} // OK if nothing to commit
+
+      // Merge session into working branch (skip session branch push — we'll push working branch after merge)
+      await execAsync(`git checkout "${workingBranch}"`, { cwd: root, timeout: 5000 })
+      await execAsync(`git merge "${branch}" --no-edit`, { cwd: root, timeout: 10000 })
+      ctx.ui.notify(`  ✓ Merged → ${workingBranch}`, { level: "info" })
+      mergeOk = true
+
+      // Delete local session branch immediately (fast, no network)
+      try {
+        await execAsync(`git branch -d "${branch}"`, { cwd: root, timeout: 5000 })
+      } catch {}
+
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err)
+      if (msg.includes("CONFLICT") || msg.includes("conflict")) {
+        ctx.ui.notify(`  ⚠ Merge conflict — branch ${branch} preserved`, { level: "warn" })
+        try { await execAsync(`git checkout "${branch}"`, { cwd: root, timeout: 5000 }) } catch {}
+      } else {
+        ctx.ui.notify(`  ⚠ Merge failed: ${msg.slice(0, 100)}`, { level: "warn" })
+        try { await execAsync(`git checkout "${branch}"`, { cwd: root, timeout: 5000 }) } catch {}
+      }
+    }
+  }
+
+  // ── PHASE 3: Parallel push + cleanup + collect ───────────────────────
+  // Push and remote cleanup are network I/O — run them in parallel with
+  // synopsis/memory collection. Single git push command does both push +
+  // remote branch delete to avoid lock contention.
+
+  const pushP = (async () => {
+    if (!mergeOk) return
+    try {
+      // Single push: update working branch AND delete remote session branch
+      // This avoids two separate network round-trips and git lock contention
+      await execAsync(
+        `git push origin "${workingBranch}" ":${branch}" 2>/dev/null || git push origin "${workingBranch}" 2>/dev/null || true`,
+        { cwd: root, timeout: 20000 }
+      )
+      ctx.ui.notify("  ✓ Pushed & cleaned up remote", { level: "info" })
+    } catch {
+      ctx.log("Push failed — run manually: git push", "warn")
+    }
+  })()
+
+  // ── PHASE 4: Await all parallel work ─────────────────────────────────
+  const [, synopsisResult] = await Promise.allSettled([hubP, synopsisP, memoryP, pushP])
+
+  // Show synopsis if we got one
+  if (synopsisResult.status === "fulfilled" && synopsisResult.value) {
+    const lines = (synopsisResult.value as string).split("\n")
+    // Show condensed version — first 20 lines max
+    const condensed = lines.slice(0, 20).join("\n")
+    if (condensed.trim()) {
+      ctx.ui.notify(`\n${condensed}`, { level: "info" })
+    }
+  }
+
+  const elapsed = ((Date.now() - t0) / 1000).toFixed(1)
+  ctx.ui.notify(`✓ Session ended (${elapsed}s)`, { level: "info" })
+
+  // ── Fallback cleanup script for non-session branches ─────────────────
+  if (!branch.startsWith("session-")) {
+    const cleanupScript = findScript(root, "session-cleanup.sh")
+    if (cleanupScript) {
+      try { await execAsync(`bash "${cleanupScript}"`, { cwd: root, timeout: 10000 }) } catch {}
+    }
+  }
+
+  ctx.emit("hook:session-end", {
+    session: ctx.session.id,
+    branch,
+    ts: new Date().toISOString(),
+  })
+}
+
+export function getCurrentBranch(root: string): string {
+  try {
+    return execSync("git branch --show-current", { cwd: root }).toString().trim()
+  } catch {
+    try {
+      const saved = readFileSync(join(root, ".jfl", "current-session-branch.txt"), "utf-8").trim()
+      return saved
+    } catch {
+      return "main"
+    }
+  }
+}