coder-config 0.42.23 → 0.42.26

package/README.md

@@ -211,7 +211,9 @@ coder-config workstream auto-activate "My Work" off     # Never auto-activate
 coder-config workstream auto-activate "My Work" default # Use global setting
 ```
 
-### Loop Commands (Ralph Loop)
+### Loop Commands (Ralph Loop) - Experimental
+
+> **Note:** Ralph Loops is an experimental feature, disabled by default. Enable it in the Web UI under **Preferences > Experimental Features**.
 
 Ralph Loops enable autonomous development - Claude Code runs continuously until a task is completed.
 
@@ -268,7 +270,7 @@ coder-config update --check     # Check for updates without installing
 coder-config update /path/src   # Update from local development source
 ```
 
-The UI also checks for updates automatically and shows a notification when a new version is available.
+The UI checks for updates automatically and auto-updates when enabled in Preferences. After server updates, the UI auto-refreshes to load the new version.
 
 ### Web UI
 
@@ -380,6 +382,44 @@ Persistent memory for Claude Code sessions.
 
 Manage via Web UI or edit files directly.
 
+## Session Persistence
+
+Save context from a Claude Code session and restore it on the next session start.
+
+### How It Works
+
+1. **Save context** - Use `/flush` in Claude Code to write a context summary
+2. **Auto-preserve** - The `session-end` hook preserves your flushed context when the session ends
+3. **Auto-restore** - The `session-start` hook injects saved context into your next session
+
+Context is automatically restored within 24 hours of being saved.
+
+### Setup
+
+```bash
+# Install the Claude Code hooks
+coder-config session install-hooks
+
+# Copy the /flush command to your Claude Code commands
+cp /path/to/coder-config/templates/commands/flush.md ~/.claude/commands/
+```
+
+### CLI Commands
+
+```bash
+coder-config session                 # Show session status
+coder-config session flush           # Instructions for saving context
+coder-config session clear           # Clear saved context
+coder-config session install-hooks   # Install Claude Code hooks
+```
+
+### Storage Location
+
+Session data is stored in `~/.coder-config/sessions/`:
+- `flushed-context.md` - Context saved by /flush command
+- `last-flushed-context.md` - Preserved context from last session end
+- `last-session.json` - Metadata about the last session
+
 ## Workstreams
 
 Workstreams are **context sets** for multi-project workflows. They group related projects and inject context rules into every Claude session.

package/config-loader.js

@@ -31,6 +31,7 @@ const { getProjectsRegistryPath, loadProjectsRegistry, saveProjectsRegistry, pro
 const { getWorkstreamsPath, loadWorkstreams, saveWorkstreams, workstreamList, workstreamCreate, workstreamUpdate, workstreamDelete, workstreamUse, workstreamActive, workstreamAddProject, workstreamRemoveProject, workstreamInject, workstreamDetect, workstreamGet, getActiveWorkstream, countWorkstreamsForProject, workstreamInstallHook, workstreamInstallHookGemini, workstreamInstallHookCodex, workstreamDeactivate, workstreamCheckPath, getSettingsPath, loadSettings, saveSettings, workstreamAddTrigger, workstreamRemoveTrigger, workstreamSetAutoActivate, setGlobalAutoActivate, shouldAutoActivate, workstreamCheckFolder, workstreamInstallCdHook, workstreamUninstallCdHook, workstreamCdHookStatus } = require('./lib/workstreams');
 const { getActivityPath, getDefaultActivity, loadActivity, saveActivity, detectProjectRoot, activityLog, activitySummary, generateWorkstreamName, activitySuggestWorkstreams, activityClear } = require('./lib/activity');
 const { getLoopsPath, loadLoops, saveLoops, loadLoopState, saveLoopState, loadHistory, saveHistory, loopList, loopCreate, loopGet, loopUpdate, loopDelete, loopStart, loopPause, loopResume, loopCancel, loopApprove, loopComplete, loopStatus, loopHistory, loopConfig, getActiveLoop, recordIteration, saveClarifications, savePlan, loadClarifications, loadPlan, loopInject, archiveLoop } = require('./lib/loops');
+const { getSessionStatus, showSessionStatus, flushContext, clearContext, installHooks: sessionInstallHooks, getFlushedContext, SESSION_DIR, FLUSHED_CONTEXT_FILE } = require('./lib/sessions');
 const { runCli } = require('./lib/cli');
 
 class ClaudeConfigManager {
@@ -205,6 +206,16 @@ class ClaudeConfigManager {
   activitySuggestWorkstreams() { return activitySuggestWorkstreams(this.installDir); }
   activityClear(olderThanDays) { return activityClear(this.installDir, olderThanDays); }
 
+  // Sessions
+  getSessionStatus() { return getSessionStatus(); }
+  sessionStatus() { return showSessionStatus(); }
+  sessionFlush() { return flushContext(); }
+  sessionClear() { return clearContext(); }
+  sessionInstallHooks() { return sessionInstallHooks(); }
+  getFlushedContext() { return getFlushedContext(); }
+  getSessionDir() { return SESSION_DIR; }
+  getFlushedContextPath() { return FLUSHED_CONTEXT_FILE; }
+
   // Update - check npm for updates or update from local source
   async update(args = []) {
     const https = require('https');

package/hooks/session-end.sh

@@ -0,0 +1,36 @@
+#!/bin/bash
+# Session End Hook - Save session info for potential resume
+# Install: Add to ~/.claude/settings.json hooks.SessionEnd
+
+# Read hook input
+INPUT=$(cat)
+SESSION_ID=$(echo "$INPUT" | jq -r '.session_id // empty')
+TRANSCRIPT_PATH=$(echo "$INPUT" | jq -r '.transcript_path // empty')
+CWD=$(echo "$INPUT" | jq -r '.cwd // empty')
+REASON=$(echo "$INPUT" | jq -r '.reason // empty')
+
+# Skip if no session ID
+[ -z "$SESSION_ID" ] && exit 0
+
+# Session state directory
+STATE_DIR="$HOME/.coder-config/sessions"
+mkdir -p "$STATE_DIR"
+
+# Save session metadata
+cat > "$STATE_DIR/last-session.json" << EOF
+{
+  "session_id": "$SESSION_ID",
+  "transcript_path": "$TRANSCRIPT_PATH",
+  "cwd": "$CWD",
+  "reason": "$REASON",
+  "timestamp": "$(date -u +"%Y-%m-%dT%H:%M:%SZ")"
+}
+EOF
+
+# If there's a flushed context file, preserve it
+FLUSH_FILE="$STATE_DIR/flushed-context.md"
+if [ -f "$FLUSH_FILE" ]; then
+  cp "$FLUSH_FILE" "$STATE_DIR/last-flushed-context.md"
+fi
+
+exit 0

package/hooks/session-start.sh

@@ -0,0 +1,35 @@
+#!/bin/bash
+# Session Start Hook - Restore context from previous session
+# Install: Add to ~/.claude/settings.json hooks.SessionStart
+
+# Session state directory
+STATE_DIR="$HOME/.coder-config/sessions"
+
+# Check for saved context to inject
+LAST_CONTEXT="$STATE_DIR/last-flushed-context.md"
+LAST_SESSION="$STATE_DIR/last-session.json"
+
+# Only inject if we have flushed context
+if [ -f "$LAST_CONTEXT" ]; then
+  # Check if context is recent (within 24 hours)
+  if [ "$(uname)" = "Darwin" ]; then
+    # macOS
+    FILE_AGE=$(( $(date +%s) - $(stat -f %m "$LAST_CONTEXT") ))
+  else
+    # Linux
+    FILE_AGE=$(( $(date +%s) - $(stat -c %Y "$LAST_CONTEXT") ))
+  fi
+
+  # 24 hours = 86400 seconds
+  if [ "$FILE_AGE" -lt 86400 ]; then
+    # Output context - Claude will see this in the session
+    echo "<session-context source=\"previous-session\">"
+    echo "The following context was saved from a previous session:"
+    echo ""
+    cat "$LAST_CONTEXT"
+    echo ""
+    echo "</session-context>"
+  fi
+fi
+
+exit 0

package/lib/cli.js

@@ -272,6 +272,19 @@ function runCli(manager) {
       }
       break;
 
+    // Session management
+    case 'session':
+      if (args[1] === 'flush') {
+        manager.sessionFlush();
+      } else if (args[1] === 'clear') {
+        manager.sessionClear();
+      } else if (args[1] === 'install-hooks') {
+        manager.sessionInstallHooks();
+      } else {
+        manager.sessionStatus();
+      }
+      break;
+
     // Maintenance
     case 'update':
       manager.update(args.slice(1)).catch(err => {
@@ -392,6 +405,12 @@ Workstream Commands:
   Per-session activation (enables parallel work):
     export CODER_WORKSTREAM=<name-or-id>
 ${loopHelp}
+Session Persistence:
+  session                    Show session status (saved context)
+  session flush              Manually save current context
+  session clear              Clear saved session context
+  session install-hooks      Install Claude Code hooks for session persistence
+
 Registry Commands:
   registry                       List MCPs in global registry
   registry add <name> '<json>'   Add MCP to global registry

package/lib/constants.js

@@ -2,7 +2,7 @@
  * Constants and tool path configurations
  */
 
-const VERSION = '0.42.23';
+const VERSION = '0.42.26';
 
 // Tool-specific path configurations
 const TOOL_PATHS = {

package/lib/sessions.js

@@ -0,0 +1,262 @@
+/**
+ * Session persistence management
+ * Saves and restores Claude Code session context
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const SESSION_DIR = path.join(os.homedir(), '.coder-config', 'sessions');
+const LAST_SESSION_FILE = path.join(SESSION_DIR, 'last-session.json');
+const FLUSHED_CONTEXT_FILE = path.join(SESSION_DIR, 'flushed-context.md');
+const LAST_FLUSHED_FILE = path.join(SESSION_DIR, 'last-flushed-context.md');
+
+/**
+ * Ensure session directory exists
+ */
+function ensureSessionDir() {
+  if (!fs.existsSync(SESSION_DIR)) {
+    fs.mkdirSync(SESSION_DIR, { recursive: true });
+  }
+}
+
+/**
+ * Get session status
+ */
+function getSessionStatus() {
+  ensureSessionDir();
+
+  const status = {
+    hasSavedContext: false,
+    lastSession: null,
+    contextAge: null,
+  };
+
+  // Check for flushed context
+  if (fs.existsSync(LAST_FLUSHED_FILE)) {
+    status.hasSavedContext = true;
+    const stat = fs.statSync(LAST_FLUSHED_FILE);
+    status.contextAge = Math.floor((Date.now() - stat.mtimeMs) / 1000 / 60); // minutes
+  } else if (fs.existsSync(FLUSHED_CONTEXT_FILE)) {
+    status.hasSavedContext = true;
+    const stat = fs.statSync(FLUSHED_CONTEXT_FILE);
+    status.contextAge = Math.floor((Date.now() - stat.mtimeMs) / 1000 / 60);
+  }
+
+  // Check for last session metadata
+  if (fs.existsSync(LAST_SESSION_FILE)) {
+    try {
+      status.lastSession = JSON.parse(fs.readFileSync(LAST_SESSION_FILE, 'utf8'));
+    } catch (e) {
+      // Ignore parse errors
+    }
+  }
+
+  return status;
+}
+
+/**
+ * Show session status
+ */
+function showSessionStatus() {
+  const status = getSessionStatus();
+
+  console.log('Session Persistence Status\n');
+
+  if (status.hasSavedContext) {
+    console.log(`  Saved context: Yes`);
+    if (status.contextAge !== null) {
+      if (status.contextAge < 60) {
+        console.log(`  Context age: ${status.contextAge} minutes`);
+      } else if (status.contextAge < 1440) {
+        console.log(`  Context age: ${Math.floor(status.contextAge / 60)} hours`);
+      } else {
+        console.log(`  Context age: ${Math.floor(status.contextAge / 1440)} days`);
+      }
+    }
+  } else {
+    console.log('  Saved context: None');
+  }
+
+  if (status.lastSession) {
+    console.log(`\n  Last session:`);
+    console.log(`    ID: ${status.lastSession.session_id || 'unknown'}`);
+    console.log(`    CWD: ${status.lastSession.cwd || 'unknown'}`);
+    console.log(`    Ended: ${status.lastSession.timestamp || 'unknown'}`);
+    console.log(`    Reason: ${status.lastSession.reason || 'unknown'}`);
+  }
+
+  console.log(`\n  Storage: ${SESSION_DIR}`);
+
+  if (!status.hasSavedContext) {
+    console.log('\nTo save context, use /flush in Claude Code or:');
+    console.log('  coder-config session flush');
+  }
+}
+
+/**
+ * Print instructions for manual flush
+ * (Actual flush happens in Claude Code via /flush command)
+ */
+function flushContext() {
+  console.log('Session context flush\n');
+  console.log('To save session context, use the /flush command in Claude Code.');
+  console.log('This tells Claude to write a summary to:');
+  console.log(`  ${FLUSHED_CONTEXT_FILE}\n`);
+  console.log('The context will be automatically restored on the next session start');
+  console.log('(if session hooks are installed).\n');
+  console.log('Install hooks with:');
+  console.log('  coder-config session install-hooks');
+}
+
+/**
+ * Clear saved session context
+ */
+function clearContext() {
+  ensureSessionDir();
+
+  let cleared = false;
+
+  if (fs.existsSync(FLUSHED_CONTEXT_FILE)) {
+    fs.unlinkSync(FLUSHED_CONTEXT_FILE);
+    cleared = true;
+  }
+
+  if (fs.existsSync(LAST_FLUSHED_FILE)) {
+    fs.unlinkSync(LAST_FLUSHED_FILE);
+    cleared = true;
+  }
+
+  if (fs.existsSync(LAST_SESSION_FILE)) {
+    fs.unlinkSync(LAST_SESSION_FILE);
+    cleared = true;
+  }
+
+  if (cleared) {
+    console.log('Session context cleared.');
+  } else {
+    console.log('No session context to clear.');
+  }
+}
+
+/**
+ * Install Claude Code hooks for session persistence
+ */
+function installHooks() {
+  const claudeDir = path.join(os.homedir(), '.claude');
+  const settingsFile = path.join(claudeDir, 'settings.json');
+
+  // Ensure .claude directory exists
+  if (!fs.existsSync(claudeDir)) {
+    fs.mkdirSync(claudeDir, { recursive: true });
+  }
+
+  // Load existing settings
+  let settings = {};
+  if (fs.existsSync(settingsFile)) {
+    try {
+      settings = JSON.parse(fs.readFileSync(settingsFile, 'utf8'));
+    } catch (e) {
+      console.error('Error reading settings.json:', e.message);
+      return;
+    }
+  }
+
+  // Initialize hooks if needed
+  if (!settings.hooks) {
+    settings.hooks = {};
+  }
+
+  // Find coder-config hooks directory
+  const hooksSrcDir = path.join(__dirname, '..', 'hooks');
+  const sessionStartHook = path.join(hooksSrcDir, 'session-start.sh');
+  const sessionEndHook = path.join(hooksSrcDir, 'session-end.sh');
+
+  // Verify hooks exist
+  if (!fs.existsSync(sessionStartHook) || !fs.existsSync(sessionEndHook)) {
+    console.error('Session hooks not found in coder-config package.');
+    console.log('Expected locations:');
+    console.log(`  ${sessionStartHook}`);
+    console.log(`  ${sessionEndHook}`);
+    return;
+  }
+
+  // Make hooks executable
+  try {
+    fs.chmodSync(sessionStartHook, '755');
+    fs.chmodSync(sessionEndHook, '755');
+  } catch (e) {
+    console.warn('Could not set executable permission on hooks:', e.message);
+  }
+
+  // Add SessionStart hook
+  if (!settings.hooks.SessionStart) {
+    settings.hooks.SessionStart = [];
+  }
+  if (!Array.isArray(settings.hooks.SessionStart)) {
+    settings.hooks.SessionStart = [settings.hooks.SessionStart];
+  }
+
+  // Check if our hook is already installed
+  const startHookEntry = { type: 'command', command: sessionStartHook };
+  const hasStartHook = settings.hooks.SessionStart.some(h =>
+    typeof h === 'object' && h.command === sessionStartHook
+  );
+  if (!hasStartHook) {
+    settings.hooks.SessionStart.push(startHookEntry);
+  }
+
+  // Add SessionEnd hook
+  if (!settings.hooks.SessionEnd) {
+    settings.hooks.SessionEnd = [];
+  }
+  if (!Array.isArray(settings.hooks.SessionEnd)) {
+    settings.hooks.SessionEnd = [settings.hooks.SessionEnd];
+  }
+
+  const endHookEntry = { type: 'command', command: sessionEndHook };
+  const hasEndHook = settings.hooks.SessionEnd.some(h =>
+    typeof h === 'object' && h.command === sessionEndHook
+  );
+  if (!hasEndHook) {
+    settings.hooks.SessionEnd.push(endHookEntry);
+  }
+
+  // Save settings
+  try {
+    fs.writeFileSync(settingsFile, JSON.stringify(settings, null, 2));
+    console.log('Session hooks installed.\n');
+    console.log('Hooks added:');
+    console.log('  - SessionStart: Restores saved context');
+    console.log('  - SessionEnd: Preserves flushed context\n');
+    console.log('To save context before exiting, use /flush in Claude Code.');
+    console.log('The saved context will be restored on the next session start.');
+  } catch (e) {
+    console.error('Error writing settings.json:', e.message);
+  }
+}
+
+/**
+ * Get flushed context content (for hooks)
+ */
+function getFlushedContext() {
+  if (fs.existsSync(LAST_FLUSHED_FILE)) {
+    return fs.readFileSync(LAST_FLUSHED_FILE, 'utf8');
+  }
+  if (fs.existsSync(FLUSHED_CONTEXT_FILE)) {
+    return fs.readFileSync(FLUSHED_CONTEXT_FILE, 'utf8');
+  }
+  return null;
+}
+
+module.exports = {
+  getSessionStatus,
+  showSessionStatus,
+  flushContext,
+  clearContext,
+  installHooks,
+  getFlushedContext,
+  SESSION_DIR,
+  FLUSHED_CONTEXT_FILE,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "coder-config",
-  "version": "0.42.23",
+  "version": "0.42.26",
   "description": "Configuration manager for AI coding tools - Claude Code, Gemini CLI, Codex CLI, Antigravity. Manage MCPs, rules, permissions, memory, and workstreams.",
   "author": "regression.io",
   "main": "config-loader.js",

package/templates/commands/flush.md

@@ -0,0 +1,47 @@
+# Flush Context to Resumable Doc
+
+Save all current session context to a resumable document that will be automatically restored on the next session start.
+
+## Instructions
+
+1. Create a comprehensive summary of the current session including:
+   - **Task Summary**: What the user asked for and the overall goal
+   - **Current State**: Where we are in the task (completed, in-progress, blocked)
+   - **Key Decisions Made**: Important choices and their rationale
+   - **Files Modified**: List of files created or changed
+   - **Pending Work**: What still needs to be done
+   - **Important Context**: Any critical information needed to continue
+
+2. Write this summary to: `~/.coder-config/sessions/flushed-context.md`
+
+3. Confirm to the user that context has been saved and will be restored on next session.
+
+## Output Format
+
+Write the file in this format:
+
+```markdown
+# Session Context - [Date]
+
+## Task Summary
+[What the user wanted to accomplish]
+
+## Current State
+[in-progress | completed | blocked]
+[Brief status description]
+
+## Key Decisions
+- [Decision 1]: [Rationale]
+- [Decision 2]: [Rationale]
+
+## Files Modified
+- `path/to/file1` - [what was changed]
+- `path/to/file2` - [what was changed]
+
+## Pending Work
+- [ ] [Task 1]
+- [ ] [Task 2]
+
+## Important Context
+[Any critical information needed to continue this work]
+```