claude-code-swarm 0.3.4 → 0.3.5

package/references/sessionlog/src/strategy/manual-commit.ts

@@ -0,0 +1,988 @@
+/**
+ * Manual Commit Strategy
+ *
+ * Core strategy implementation that orchestrates session tracking,
+ * checkpoint creation, condensation, and git hook integration.
+ *
+ * Data flow:
+ * 1. InitializeSession -> Creates SessionState, calculates initial attribution
+ * 2. SaveStep/SaveTaskStep -> Writes to shadow branch via CheckpointStore
+ * 3. PrepareCommitMsg -> Adds Sessionlog-Checkpoint trailer to commit messages
+ * 4. PostCommit -> Condenses session data, handles carry-forward
+ * 5. PrePush -> Pushes metadata branch alongside user push
+ */
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import type { SessionStore } from '../store/session-store.js';
+import type { CheckpointStore } from '../store/checkpoint-store.js';
+import type { SessionState, CheckpointID } from '../types.js';
+import {
+  addTokenUsage,
+  CHECKPOINTS_BRANCH,
+  SHADOW_BRANCH_PREFIX,
+  validateCheckpointID,
+} from '../types.js';
+import {
+  git,
+  gitSafe,
+  getHead,
+  getCurrentBranch,
+  getWorktreeRoot,
+  getGitAuthor,
+  getUntrackedFiles,
+  refExists,
+  pushBranch,
+  hasUncommittedChanges,
+  listBranches,
+  showFile,
+  lsTree,
+  deleteBranch,
+  updateRef,
+  diffNameOnly,
+} from '../git-operations.js';
+import { parseCheckpoint, formatShadowCommit, CheckpointTrailerKey } from '../utils/trailers.js';
+import {
+  filesOverlapWithContent,
+  stagedFilesOverlapWithContent,
+  filesWithRemainingAgentChanges,
+} from './content-overlap.js';
+import type {
+  Strategy,
+  StepContext,
+  TaskStepContext,
+  CondensationResult,
+  RewindPoint,
+  OrphanedItem,
+} from './types.js';
+import { STRATEGY_NAME_MANUAL_COMMIT, formatSubagentEndMessage } from './types.js';
+import { appendCheckpointEvent } from '../events/event-log.js';
+
+// ============================================================================
+// ManualCommitStrategy
+// ============================================================================
+
+export interface ManualCommitStrategyConfig {
+  sessionStore: SessionStore;
+  checkpointStore: CheckpointStore;
+  cwd?: string;
+  /** When a separate session repo is configured, this is its working directory.
+   *  Used for pushing the checkpoints branch from the correct repo. */
+  sessionRepoCwd?: string;
+  /** Override for the checkpoints branch name (e.g. project-namespaced). */
+  checkpointsBranch?: string;
+  /** Enable the JSONL event log (.sessionlog/events.jsonl).
+   *  When true, checkpoint events are appended after each commit. */
+  eventLogEnabled?: boolean;
+  /** Maximum number of events to retain in the event log file.
+   *  When set, the log is pruned to this many entries after each write.
+   *  0 or undefined means keep all events. */
+  eventLogMaxEvents?: number;
+}
+
+export function createManualCommitStrategy(config: ManualCommitStrategyConfig): Strategy {
+  const { sessionStore, checkpointStore, cwd, sessionRepoCwd } = config;
+  /** The cwd for operations on the committed checkpoints branch */
+  const committedCwd = sessionRepoCwd ?? cwd;
+  /** Branch name for committed checkpoints */
+  const cpBranch = config.checkpointsBranch ?? CHECKPOINTS_BRANCH;
+
+  // ========================================================================
+  // Session State Helpers
+  // ========================================================================
+
+  async function loadSession(sessionID: string): Promise<SessionState | null> {
+    return sessionStore.load(sessionID);
+  }
+
+  async function saveSession(state: SessionState): Promise<void> {
+    await sessionStore.save(state);
+  }
+
+  async function listAllSessions(): Promise<SessionState[]> {
+    return sessionStore.list();
+  }
+
+  async function findSessionsForCommit(baseCommitSHA: string): Promise<SessionState[]> {
+    const all = await listAllSessions();
+    return all.filter((s) => s.baseCommit === baseCommitSHA);
+  }
+
+  function getShadowBranchName(baseCommit: string, worktreeID?: string): string {
+    return checkpointStore.getShadowBranchName(baseCommit, worktreeID);
+  }
+
+  // ========================================================================
+  // File Merging Helpers
+  // ========================================================================
+
+  function mergeFilesTouched(existing: string[], ...fileLists: string[][]): string[] {
+    const seen = new Set(existing);
+    for (const list of fileLists) {
+      for (const f of list) seen.add(f);
+    }
+    return Array.from(seen).sort();
+  }
+
+  // ========================================================================
+  // Strategy Implementation
+  // ========================================================================
+
+  const strategy: Strategy = {
+    name: STRATEGY_NAME_MANUAL_COMMIT,
+
+    // ======================================================================
+    // PrepareCommitMsg - Add checkpoint trailer to commit messages
+    // ======================================================================
+    async prepareCommitMsg(commitMsgFile: string, source: string, _sha: string): Promise<void> {
+      // Read the current commit message
+      const commitMsg = fs.readFileSync(commitMsgFile, 'utf-8');
+
+      // Skip merge commits
+      if (source === 'merge') return;
+
+      // Handle amend: preserve existing checkpoint trailer
+      if (source === 'commit') {
+        const [cpID, found] = parseCheckpoint(commitMsg);
+        if (found && cpID) {
+          // Trailer already present, nothing to do
+          return;
+        }
+      }
+
+      // Get current HEAD
+      const head = await getHead(cwd);
+
+      // Find active sessions for this commit
+      const sessions = await findSessionsForCommit(head);
+      if (sessions.length === 0) return;
+
+      // Get staged files
+      const stagedOutput = await gitSafe(
+        ['diff', '--cached', '--name-only', '--diff-filter=ACMRD'],
+        { cwd },
+      );
+      if (!stagedOutput) return;
+      const stagedFiles = stagedOutput
+        .trim()
+        .split('\n')
+        .filter((f) => f.length > 0);
+      if (stagedFiles.length === 0) return;
+
+      // Check if any session has overlapping work
+      let hasOverlap = false;
+      let overlappingSession: SessionState | null = null;
+
+      for (const state of sessions) {
+        if (state.stepCount === 0 || state.filesTouched.length === 0) continue;
+
+        const shadowBranch = getShadowBranchName(state.baseCommit, state.worktreeID);
+        const exists = await refExists(`refs/heads/${shadowBranch}`, cwd);
+        if (!exists) continue;
+
+        // Content-aware overlap check
+        const overlap = await stagedFilesOverlapWithContent(
+          shadowBranch,
+          stagedFiles,
+          state.filesTouched,
+          cwd,
+        );
+
+        if (overlap) {
+          hasOverlap = true;
+          overlappingSession = state;
+          break;
+        }
+      }
+
+      // Fallback: handle active sessions where the agent is committing mid-turn.
+      // At this point TurnEnd hasn't fired, so stepCount/filesTouched/shadow branch
+      // may not exist yet. Use staged files as a proxy for agent work.
+      if (!hasOverlap) {
+        for (const state of sessions) {
+          if (state.phase !== 'active') continue;
+
+          try {
+            const shadowBranch = getShadowBranchName(state.baseCommit, state.worktreeID);
+            let shadowExists = await refExists(`refs/heads/${shadowBranch}`, cwd);
+
+            if (!shadowExists) {
+              const author = await getGitAuthor(cwd);
+              // Use flat name (no slashes) — mergeMetadataIntoTree can't handle nested paths
+              const metadataDir = `sessionlog-${state.sessionID}`;
+              const result = await checkpointStore.writeTemporary({
+                sessionID: state.sessionID,
+                baseCommit: state.baseCommit,
+                worktreeID: state.worktreeID,
+                modifiedFiles: stagedFiles,
+                newFiles: [],
+                deletedFiles: [],
+                metadataDir,
+                metadataDirAbs: path.resolve(cwd ?? '.', metadataDir),
+                commitMessage: formatShadowCommit(
+                  `Checkpoint: ${stagedFiles.length} file(s)`,
+                  metadataDir,
+                  state.sessionID,
+                ),
+                authorName: author.name,
+                authorEmail: author.email,
+                isFirstCheckpoint: true,
+              });
+              if (!result.skipped) {
+                shadowExists = true;
+              }
+            }
+
+            if (shadowExists) {
+              // Update session state so postCommit can process it
+              state.stepCount = Math.max(state.stepCount, 1);
+              state.filesTouched = mergeFilesTouched(state.filesTouched, stagedFiles);
+              await saveSession(state);
+              hasOverlap = true;
+              overlappingSession = state;
+              break;
+            }
+          } catch {
+            // Non-fatal
+          }
+        }
+      }
+
+      if (!hasOverlap || !overlappingSession) return;
+
+      // Generate or reuse checkpoint ID
+      let cpID: CheckpointID;
+      if (
+        overlappingSession.lastCheckpointID &&
+        validateCheckpointID(overlappingSession.lastCheckpointID)
+      ) {
+        cpID = overlappingSession.lastCheckpointID;
+      } else {
+        cpID = await checkpointStore.generateID();
+      }
+
+      // Inject trailer into commit message
+      const trailer = `${CheckpointTrailerKey}: ${cpID}`;
+      const injected = injectCheckpointTrailer(commitMsg, trailer);
+      fs.writeFileSync(commitMsgFile, injected, 'utf-8');
+    },
+
+    // ======================================================================
+    // PostCommit - Condense session data after commit
+    // ======================================================================
+    async postCommit(): Promise<void> {
+      // Read HEAD commit message
+      const headHash = await getHead(cwd);
+      const commitMsg = await git(['log', '-1', '--format=%B', headHash], { cwd });
+
+      // Check for checkpoint trailer
+      const [cpID, found] = parseCheckpoint(commitMsg);
+      if (!found || !cpID) return;
+
+      // Find sessions for the parent commit (our base)
+      const parentHash = await gitSafe(['rev-parse', `${headHash}^`], { cwd });
+      if (!parentHash) return;
+
+      const sessions = await findSessionsForCommit(parentHash.trim());
+      if (sessions.length === 0) return;
+
+      // Get files changed in this commit
+      const { added, modified, deleted } = await diffNameOnly(`${headHash}^`, headHash, cwd);
+      const committedFiles = new Set([...added, ...modified, ...deleted]);
+
+      // Process each session
+      for (const state of sessions) {
+        if (state.stepCount === 0 || state.filesTouched.length === 0) continue;
+
+        const shadowBranch = getShadowBranchName(state.baseCommit, state.worktreeID);
+        const exists = await refExists(`refs/heads/${shadowBranch}`, cwd);
+        if (!exists) continue;
+
+        // Check overlap with committed files
+        const overlap = await filesOverlapWithContent(
+          shadowBranch,
+          headHash,
+          parentHash.trim(),
+          state.filesTouched,
+          cwd,
+        );
+        if (!overlap) continue;
+
+        // Condense this session
+        try {
+          await condenseSession(state, cpID, committedFiles);
+        } catch {
+          // Log but continue with other sessions
+        }
+
+        // Handle carry-forward for remaining files
+        const remaining = await filesWithRemainingAgentChanges(
+          shadowBranch,
+          headHash,
+          state.filesTouched,
+          committedFiles,
+          cwd,
+        );
+
+        if (remaining.length === 0) {
+          // All files committed - clean up shadow branch
+          try {
+            await checkpointStore.deleteShadowBranch(shadowBranch);
+          } catch {
+            // Best effort cleanup
+          }
+
+          // Update session for new base commit
+          state.baseCommit = headHash;
+          state.stepCount = 0;
+          state.filesTouched = [];
+          state.promptAttributions = [];
+          state.lastCheckpointID = cpID;
+          await saveSession(state);
+        } else {
+          // Carry forward: update state for remaining files
+          state.baseCommit = headHash;
+          state.filesTouched = remaining;
+          state.stepCount = 0;
+          state.promptAttributions = [];
+          state.lastCheckpointID = cpID;
+          await saveSession(state);
+        }
+      }
+    },
+
+    // ======================================================================
+    // CommitMsg - Strip trailer if no user content (prevents empty commits)
+    // ======================================================================
+    async commitMsg(commitMsgFile: string): Promise<void> {
+      let content: string;
+      try {
+        content = fs.readFileSync(commitMsgFile, 'utf-8');
+      } catch {
+        return; // Hook must be silent on failure
+      }
+
+      // Check if our trailer is present
+      const [, found] = parseCheckpoint(content);
+      if (!found) return;
+
+      // Check if there's any user content (non-comment, non-trailer lines)
+      if (!hasUserContent(content)) {
+        // No user content - strip the trailer so git aborts the commit
+        const stripped = stripCheckpointTrailer(content);
+        try {
+          fs.writeFileSync(commitMsgFile, stripped, 'utf-8');
+        } catch {
+          // Hook must be silent on failure
+        }
+      }
+    },
+
+    // ======================================================================
+    // PrePush - Push metadata branch alongside user push
+    // ======================================================================
+    async prePush(remote: string): Promise<void> {
+      const pushCwd = committedCwd;
+      const branchExists = await refExists(`refs/heads/${cpBranch}`, pushCwd);
+      if (!branchExists) return;
+
+      try {
+        await pushBranch(remote, cpBranch, false, pushCwd);
+      } catch {
+        // Non-fatal: metadata push failure shouldn't block user push
+      }
+    },
+
+    // ======================================================================
+    // SaveStep - Create session checkpoint on shadow branch
+    // ======================================================================
+    async saveStep(step: StepContext): Promise<void> {
+      const sessionID = path.basename(step.metadataDir);
+      let state = await loadSession(sessionID);
+
+      // Initialize if needed
+      if (!state || !state.baseCommit) {
+        const head = await getHead(cwd);
+        const untrackedFiles = await getUntrackedFiles(cwd);
+        const worktreeRoot = await getWorktreeRoot(cwd);
+
+        state = {
+          sessionID,
+          baseCommit: head,
+          attributionBaseCommit: head,
+          startedAt: new Date().toISOString(),
+          phase: 'active',
+          turnCheckpointIDs: [],
+          stepCount: 0,
+          checkpointTranscriptStart: 0,
+          untrackedFilesAtStart: untrackedFiles,
+          filesTouched: [],
+          agentType: step.agentType,
+          worktreePath: worktreeRoot,
+        };
+        await saveSession(state);
+      }
+
+      // Migrate shadow branch if HEAD changed (rebase/pull mid-session)
+      await migrateAndPersist(state);
+
+      // Write temporary checkpoint
+      const isFirstCheckpoint = state.stepCount === 0;
+      const result = await checkpointStore.writeTemporary({
+        sessionID,
+        baseCommit: state.baseCommit,
+        worktreeID: state.worktreeID,
+        modifiedFiles: step.modifiedFiles,
+        newFiles: step.newFiles,
+        deletedFiles: step.deletedFiles,
+        metadataDir: step.metadataDir,
+        metadataDirAbs: step.metadataDirAbs,
+        commitMessage: step.commitMessage,
+        authorName: step.authorName,
+        authorEmail: step.authorEmail,
+        isFirstCheckpoint,
+      });
+
+      if (result.skipped) return;
+
+      // Update session state
+      state.stepCount++;
+      state.filesTouched = mergeFilesTouched(
+        state.filesTouched,
+        step.modifiedFiles,
+        step.newFiles,
+        step.deletedFiles,
+      );
+
+      if (state.stepCount === 1 && step.stepTranscriptIdentifier) {
+        state.transcriptIdentifierAtStart = step.stepTranscriptIdentifier;
+      }
+
+      if (step.tokenUsage) {
+        state.tokenUsage = state.tokenUsage
+          ? addTokenUsage(state.tokenUsage, step.tokenUsage)
+          : step.tokenUsage;
+      }
+
+      await saveSession(state);
+    },
+
+    // ======================================================================
+    // SaveTaskStep - Create task checkpoint on shadow branch
+    // ======================================================================
+    async saveTaskStep(step: TaskStepContext): Promise<void> {
+      let state = await loadSession(step.sessionID);
+
+      if (!state || !state.baseCommit) {
+        const head = await getHead(cwd);
+        const untrackedFiles = await getUntrackedFiles(cwd);
+        const worktreeRoot = await getWorktreeRoot(cwd);
+
+        state = {
+          sessionID: step.sessionID,
+          baseCommit: head,
+          attributionBaseCommit: head,
+          startedAt: new Date().toISOString(),
+          phase: 'active',
+          turnCheckpointIDs: [],
+          stepCount: 0,
+          checkpointTranscriptStart: 0,
+          untrackedFilesAtStart: untrackedFiles,
+          filesTouched: [],
+          agentType: step.agentType,
+          worktreePath: worktreeRoot,
+        };
+        await saveSession(state);
+      }
+
+      // Migrate shadow branch if HEAD changed (rebase/pull mid-session)
+      await migrateAndPersist(state);
+
+      // Generate commit message for task checkpoint
+      const shortToolUseID =
+        step.toolUseID.length > 7 ? step.toolUseID.slice(0, 7) : step.toolUseID;
+      const messageSubject = formatSubagentEndMessage(
+        step.subagentType,
+        step.taskDescription,
+        shortToolUseID,
+      );
+      const metadataDir = `.sessionlog/metadata/${step.sessionID}/tasks/${step.toolUseID}`;
+      const commitMsg = formatShadowCommit(messageSubject, metadataDir, step.sessionID);
+
+      // Write temporary checkpoint
+      await checkpointStore.writeTemporary({
+        sessionID: step.sessionID,
+        baseCommit: state.baseCommit,
+        worktreeID: state.worktreeID,
+        modifiedFiles: step.modifiedFiles,
+        newFiles: step.newFiles,
+        deletedFiles: step.deletedFiles,
+        metadataDir,
+        metadataDirAbs: path.resolve(cwd ?? '.', metadataDir),
+        commitMessage: commitMsg,
+        authorName: step.authorName,
+        authorEmail: step.authorEmail,
+        isFirstCheckpoint: state.stepCount === 0,
+      });
+
+      // Update session state
+      state.filesTouched = mergeFilesTouched(
+        state.filesTouched,
+        step.modifiedFiles,
+        step.newFiles,
+        step.deletedFiles,
+      );
+      await saveSession(state);
+    },
+
+    // ======================================================================
+    // Rewind operations
+    // ======================================================================
+    async getRewindPoints(limit: number): Promise<RewindPoint[]> {
+      const head = await getHead(cwd);
+      const sessions = await findSessionsForCommit(head);
+      const allPoints: RewindPoint[] = [];
+
+      for (const state of sessions) {
+        const shadowBranch = getShadowBranchName(state.baseCommit, state.worktreeID);
+        const exists = await refExists(`refs/heads/${shadowBranch}`, cwd);
+        if (!exists) continue;
+
+        // List temporary checkpoints
+        const temps = await checkpointStore.listTemporary();
+        for (const temp of temps) {
+          if (temp.baseCommit !== state.baseCommit) continue;
+
+          allPoints.push({
+            id: temp.latestCommit,
+            message: `Checkpoint on ${shadowBranch}`,
+            date: new Date(temp.timestamp),
+            isTaskCheckpoint: false,
+            isLogsOnly: false,
+            agent: state.agentType,
+            sessionID: state.sessionID,
+            sessionPrompt: state.firstPrompt,
+            sessionCount: 1,
+            sessionIDs: [state.sessionID],
+          });
+        }
+      }
+
+      // Sort by date descending
+      allPoints.sort((a, b) => b.date.getTime() - a.date.getTime());
+
+      // Also add logs-only points from commit history
+      const logsOnlyPoints = await getLogsOnlyRewindPoints(limit);
+      const existingIDs = new Set(allPoints.map((p) => p.id));
+      for (const p of logsOnlyPoints) {
+        if (!existingIDs.has(p.id)) {
+          allPoints.push(p);
+        }
+      }
+
+      // Re-sort and trim
+      allPoints.sort((a, b) => b.date.getTime() - a.date.getTime());
+      return allPoints.slice(0, limit);
+    },
+
+    async rewind(point: RewindPoint): Promise<void> {
+      if (point.isLogsOnly) {
+        throw new Error('Use restoreLogsOnly for logs-only rewind points');
+      }
+
+      // Read checkpoint tree and restore files
+      const treeEntries = await lsTree(point.id, undefined, cwd);
+      const worktreeRoot = await getWorktreeRoot(cwd);
+
+      for (const entry of treeEntries) {
+        if (entry.name.startsWith('.sessionlog/')) continue;
+
+        try {
+          const content = await showFile(point.id, entry.name, cwd);
+          const absPath = path.join(worktreeRoot, entry.name);
+          const dir = path.dirname(absPath);
+          fs.mkdirSync(dir, { recursive: true });
+
+          const perm = entry.mode === '100755' ? 0o755 : 0o644;
+          fs.writeFileSync(absPath, content, { mode: perm });
+        } catch {
+          // Skip files that can't be restored
+        }
+      }
+    },
+
+    async canRewind(): Promise<[boolean, string]> {
+      const hasChanges = await hasUncommittedChanges(cwd);
+      if (hasChanges) {
+        return [
+          true,
+          'Warning: You have uncommitted changes that will be overwritten by the rewind.',
+        ];
+      }
+      return [true, ''];
+    },
+
+    // ======================================================================
+    // Condensation
+    // ======================================================================
+    async condense(sessionID: string): Promise<CondensationResult> {
+      const state = await loadSession(sessionID);
+      if (!state) {
+        throw new Error(`Session not found: ${sessionID}`);
+      }
+
+      const cpID = await checkpointStore.generateID();
+      const committedFiles = new Set(state.filesTouched);
+      return condenseSession(state, cpID, committedFiles);
+    },
+
+    // ======================================================================
+    // Validation & Cleanup
+    // ======================================================================
+
+    async validateRepository(): Promise<void> {
+      const { validateRepository: validate } = await import('./common.js');
+      await validate(cwd);
+    },
+
+    async listOrphanedItems(): Promise<OrphanedItem[]> {
+      const items: OrphanedItem[] = [];
+
+      // Find orphaned shadow branches
+      const allBranches = await listBranches(cwd);
+      for (const branch of allBranches) {
+        if (branch.startsWith(SHADOW_BRANCH_PREFIX) && branch !== CHECKPOINTS_BRANCH) {
+          items.push({
+            type: 'shadow-branch',
+            id: branch,
+            reason: 'shadow branch (should have been auto-cleaned)',
+          });
+        }
+      }
+
+      return items;
+    },
+  };
+
+  // ========================================================================
+  // Internal: Condensation
+  // ========================================================================
+
+  async function condenseSession(
+    state: SessionState,
+    checkpointID: CheckpointID,
+    committedFiles: Set<string>,
+  ): Promise<CondensationResult> {
+    const author = await getGitAuthor(cwd);
+    const branch = await getCurrentBranch(cwd);
+
+    // Filter filesTouched to committed subset
+    const filesTouched = state.filesTouched.filter((f) => committedFiles.has(f));
+
+    // Build transcript and prompts from shadow branch
+    let transcript = Buffer.alloc(0);
+    let prompts: string[] = [];
+    let context = Buffer.alloc(0);
+
+    const shadowBranch = getShadowBranchName(state.baseCommit, state.worktreeID);
+    const shadowExists = await refExists(`refs/heads/${shadowBranch}`, cwd);
+
+    if (shadowExists) {
+      // Read transcript from shadow branch metadata
+      try {
+        const metadataDir = `.sessionlog/metadata/${state.sessionID}`;
+        const fullContent = await gitSafe(
+          ['show', `refs/heads/${shadowBranch}:${metadataDir}/full.jsonl`],
+          { cwd },
+        );
+        if (fullContent) {
+          transcript = Buffer.from(fullContent, 'utf-8');
+        }
+      } catch {
+        // Use empty transcript
+      }
+
+      // Read prompts
+      try {
+        const metadataDir = `.sessionlog/metadata/${state.sessionID}`;
+        const promptContent = await gitSafe(
+          ['show', `refs/heads/${shadowBranch}:${metadataDir}/prompt.txt`],
+          { cwd },
+        );
+        if (promptContent) {
+          prompts = promptContent.split('\n---\n').filter((p) => p.trim().length > 0);
+        }
+      } catch {
+        // Use empty prompts
+      }
+    }
+
+    // If we have a live transcript path, try to read from there
+    if (transcript.length === 0 && state.transcriptPath) {
+      try {
+        transcript = fs.readFileSync(state.transcriptPath);
+      } catch {
+        // Keep empty
+      }
+    }
+
+    // Generate context from prompts
+    if (prompts.length > 0) {
+      const contextLines = prompts.map((p, i) => `## Prompt ${i + 1}\n\n${p}`);
+      context = Buffer.from(contextLines.join('\n\n---\n\n'), 'utf-8');
+    }
+
+    // Write committed checkpoint
+    await checkpointStore.writeCommitted({
+      checkpointID,
+      sessionID: state.sessionID,
+      strategy: STRATEGY_NAME_MANUAL_COMMIT,
+      branch: branch ?? undefined,
+      transcript,
+      prompts,
+      context,
+      filesTouched,
+      checkpointsCount: state.stepCount,
+      authorName: author.name,
+      authorEmail: author.email,
+      agent: state.agentType,
+      turnID: state.turnID,
+      transcriptIdentifierAtStart: state.transcriptIdentifierAtStart,
+      checkpointTranscriptStart: state.checkpointTranscriptStart,
+      tokenUsage: state.tokenUsage,
+      tasks: state.tasks,
+      planModeUsed: (state.planModeEntries ?? 0) > 0,
+      planModeEntries: state.planModeEntries,
+      planEntries: state.planEntries,
+      skillsUsed: state.skillsUsed,
+    });
+
+    // Write event to the JSONL event log for external consumers (opt-in)
+    if (config.eventLogEnabled) {
+      try {
+        const eventCwd = cwd ?? process.cwd();
+        await appendCheckpointEvent(
+          eventCwd,
+          {
+            type: 'checkpoint_committed',
+            timestamp: new Date().toISOString(),
+            checkpointID,
+            sessionID: state.sessionID,
+            agent: state.agentType,
+            branch: branch ?? undefined,
+            filesTouched,
+            checkpointsCount: state.stepCount,
+            tokenUsage: state.tokenUsage,
+          },
+          { maxEvents: config.eventLogMaxEvents },
+        );
+      } catch {
+        // Non-fatal: event log failure shouldn't break checkpoint flow
+      }
+    }
+
+    return {
+      checkpointID,
+      sessionsCondensed: 1,
+      checkpointsCount: state.stepCount,
+      filesTouched,
+      tokenUsage: state.tokenUsage,
+    };
+  }
+
+  // ========================================================================
+  // Internal: Logs-only rewind points from commit history
+  // ========================================================================
+
+  async function getLogsOnlyRewindPoints(limit: number): Promise<RewindPoint[]> {
+    const points: RewindPoint[] = [];
+
+    // Check if checkpoints branch exists (in session repo if configured)
+    const branchExists = await refExists(`refs/heads/${cpBranch}`, committedCwd);
+    if (!branchExists) return points;
+
+    // Get committed checkpoints
+    const committed = await checkpointStore.listCommitted(limit);
+    if (committed.length === 0) return points;
+
+    // Build map of checkpoint IDs
+    const cpMap = new Map<string, (typeof committed)[0]>();
+    for (const cp of committed) {
+      if (cp.checkpointID) {
+        cpMap.set(cp.checkpointID, cp);
+      }
+    }
+
+    // Walk commit history looking for checkpoint trailers
+    const head = await getHead(cwd);
+    const logOutput = await gitSafe(
+      ['log', '--format=%H %s%n%b', `--max-count=${limit * 2}`, head],
+      { cwd },
+    );
+    if (!logOutput) return points;
+
+    // Parse log output looking for checkpoint trailers
+    const commits = logOutput.split('\n\n').filter((c) => c.trim().length > 0);
+
+    for (const commitBlock of commits) {
+      const lines = commitBlock.split('\n');
+      if (lines.length === 0) continue;
+
+      const firstLine = lines[0];
+      const spaceIdx = firstLine.indexOf(' ');
+      if (spaceIdx < 0) continue;
+
+      const sha = firstLine.slice(0, spaceIdx);
+      const message = firstLine.slice(spaceIdx + 1);
+      const body = lines.slice(1).join('\n');
+      const fullMessage = `${message}\n${body}`;
+
+      const [cpID, found] = parseCheckpoint(fullMessage);
+      if (!found || !cpID) continue;
+
+      const cpInfo = cpMap.get(cpID);
+      if (!cpInfo) continue;
+
+      points.push({
+        id: sha,
+        message,
+        date: new Date(),
+        isLogsOnly: true,
+        isTaskCheckpoint: false,
+        checkpointID: cpID,
+        sessionCount: cpInfo.sessions?.length ?? 1,
+        sessionIDs: [],
+      });
+
+      if (points.length >= limit) break;
+    }
+
+    return points;
+  }
+
+  // ========================================================================
+  // Internal: Shadow branch migration
+  // ========================================================================
+
+  /**
+   * Check if HEAD has changed since the session started and migrate the
+   * shadow branch to the new base commit if needed.
+   *
+   * This handles the scenario where the agent performs a rebase, pull, or
+   * other git operation that changes HEAD mid-session. Without migration,
+   * checkpoints would be saved to an orphaned shadow branch.
+   */
+  async function migrateShadowBranchIfNeeded(state: SessionState): Promise<boolean> {
+    if (!state.baseCommit) return false;
+
+    const currentHead = await getHead(cwd);
+    if (state.baseCommit === currentHead) return false;
+
+    const oldShadowBranch = getShadowBranchName(state.baseCommit, state.worktreeID);
+    const newShadowBranch = getShadowBranchName(currentHead, state.worktreeID);
+
+    // Guard: if both commits produce the same shadow branch name
+    // (same 7-char prefix), just update state
+    if (oldShadowBranch === newShadowBranch) {
+      state.baseCommit = currentHead;
+      return true;
+    }
+
+    const oldExists = await refExists(`refs/heads/${oldShadowBranch}`, cwd);
+    if (!oldExists) {
+      // Old shadow branch doesn't exist — just update baseCommit
+      state.baseCommit = currentHead;
+      return true;
+    }
+
+    // Old shadow branch exists — rename it to the new base
+    try {
+      // Read the current tip of the old branch
+      const oldTip = await git(['rev-parse', `refs/heads/${oldShadowBranch}`], { cwd });
+
+      // Create new branch pointing to same commit
+      await updateRef(`refs/heads/${newShadowBranch}`, oldTip.trim(), cwd);
+
+      // Delete old branch (best effort)
+      try {
+        await deleteBranch(oldShadowBranch, false, cwd);
+      } catch {
+        // Non-fatal
+      }
+    } catch {
+      // If rename fails, just update state
+    }
+
+    state.baseCommit = currentHead;
+    return true;
+  }
+
+  /**
+   * Check for HEAD changes, migrate shadow branch if needed, and persist.
+   */
+  async function migrateAndPersist(state: SessionState): Promise<void> {
+    const migrated = await migrateShadowBranchIfNeeded(state);
+    if (migrated) {
+      await saveSession(state);
+    }
+  }
+
+  return strategy;
+}
+
+// ============================================================================
+// Helpers
+// ============================================================================
+
+/**
+ * Inject a checkpoint trailer before any git comments in the commit message.
+ */
+function injectCheckpointTrailer(message: string, trailer: string): string {
+  const lines = message.split('\n');
+
+  // Find where git comments start (lines beginning with #)
+  let insertIndex = lines.length;
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].startsWith('#')) {
+      insertIndex = i;
+      break;
+    }
+  }
+
+  // Insert trailer before comments, with a blank line separator
+  const before = lines.slice(0, insertIndex);
+  const after = lines.slice(insertIndex);
+
+  // Ensure there's a blank line before the trailer
+  while (before.length > 0 && before[before.length - 1].trim() === '') {
+    before.pop();
+  }
+
+  return [...before, '', trailer, '', ...after].join('\n');
+}
+
+/**
+ * Check if a commit message has any content besides comments and our trailer.
+ */
+export function hasUserContent(message: string): boolean {
+  const trailerPrefix = CheckpointTrailerKey + ':';
+  for (const line of message.split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    if (trimmed.startsWith('#')) continue;
+    if (trimmed.startsWith(trailerPrefix)) continue;
+    return true;
+  }
+  return false;
+}
+
+/**
+ * Remove the Sessionlog-Checkpoint trailer line from a commit message.
+ */
+export function stripCheckpointTrailer(message: string): string {
+  const trailerPrefix = CheckpointTrailerKey + ':';
+  return message
+    .split('\n')
+    .filter((line) => !line.trim().startsWith(trailerPrefix))
+    .join('\n');
+}