@hailer/mcp 1.0.29 → 1.1.3

package/.claude/hooks/app-edit-guard.cjs

@@ -42,10 +42,26 @@
 
 const fs = require('fs');
 const path = require('path');
+const os = require('os');
+
+// Skip in yolo mode
+try {
+  const statePath = path.join(process.env.CLAUDE_PROJECT_DIR || process.cwd(), '.claude', 'yolo-state.json');
+  const state = JSON.parse(fs.readFileSync(statePath, 'utf8'));
+  if (state.mode === 'yolo') process.exit(0);
+} catch {}
+
+// Skip in subagent context - subagents can't use AskUserQuestion or Bash to recover
+// Orchestrator should use --agent-on before spawning, but this is a safety fallback
+if (process.env.CLAUDE_AGENT_ID || process.env.CLAUDE_SUBAGENT) {
+  console.log(JSON.stringify({ decision: 'allow' }));
+  process.exit(0);
+}
 
-const RELEASE_TRACKER = '/tmp/.claude-released-apps.json';
-const BUILDER_MODE_DIR = '/tmp/.claude-builder-mode';
-const BUILDER_AGENT_ACTIVE = '/tmp/.claude-builder-agent-active';
+const TEMP_DIR = os.tmpdir();
+const RELEASE_TRACKER = path.join(TEMP_DIR, '.claude-released-apps.json');
+const BUILDER_MODE_DIR = path.join(TEMP_DIR, '.claude-builder-mode');
+const BUILDER_AGENT_ACTIVE = path.join(TEMP_DIR, '.claude-builder-agent-active');
 
 // Read hook input from stdin
 let input = '';
@@ -288,7 +304,7 @@ OR: Release for manual editing (if user explicitly requests)
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
 Ask the user first! If they confirm manual editing, run:
-  Bash: node .claude/hooks/app-edit-guard.cjs --release "${appInfo.path}"
+  Bash: node "${process.argv[1].replace(/'/g, "'\\''")}" --release "${appInfo.path}"
 
 Then retry your edit.
 `);

package/.claude/hooks/auto-learn.cjs

@@ -0,0 +1,316 @@
+#!/usr/bin/env node
+/**
+ * <hook-name>auto-learn</hook-name>
+ *
+ * <purpose>
+ * Detects potential learnings from agent responses and prompts user to confirm.
+ * Only appends to LEARNINGS.md after user approval.
+ * Complements manual /learn command.
+ * </purpose>
+ *
+ * <triggers>
+ * - PostToolUse on Task (agent completions)
+ * </triggers>
+ *
+ * <detection-patterns>
+ * - "learned that", "discovered that", "found that"
+ * - "note:", "important:", "gotcha:", "tip:"
+ * - "always", "never", "must", "should" (in context of rules)
+ * - "the trick is", "the key is", "turns out"
+ * </detection-patterns>
+ *
+ * <behavior>
+ * 1. Scan tool response for learning patterns
+ * 2. If found, output prompt for Claude to use AskUserQuestion
+ * 3. User confirms which learnings to save
+ * 4. Claude runs --save command to append to LEARNINGS.md
+ * </behavior>
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+// Skip in yolo mode
+try {
+  const statePath = path.join(process.env.CLAUDE_PROJECT_DIR || process.cwd(), '.claude', 'yolo-state.json');
+  const state = JSON.parse(fs.readFileSync(statePath, 'utf8'));
+  if (state.mode === 'yolo') process.exit(0);
+} catch (e) {
+  // ENOENT is expected when not in yolo mode - only warn on unexpected errors
+  if (e.code !== 'ENOENT' && !e.message.includes('Unexpected')) {
+    console.error(`[auto-learn] Warning: ${e.message}`);
+  }
+}
+
+const LEARNINGS_FILE = path.join(
+  process.env.HAILER_INBOX_DIR || path.join(process.env.CLAUDE_PROJECT_DIR || process.cwd(), 'inbox'),
+  'learnings.md'
+);
+const PENDING_FILE = path.join(os.tmpdir(), '.claude-pending-learnings.json');
+
+// Patterns that indicate a learning/insight
+const LEARNING_PATTERNS = [
+  /(?:i |we |claude )(?:learned|discovered|found|realized) that (.{20,150})/i,
+  /(?:note|important|gotcha|tip|caveat|warning):\s*(.{20,150})/i,
+  /(?:the (?:trick|key|solution|fix) (?:is|was)) (.{20,150})/i,
+  /(?:turns out|it turns out) (.{20,150})/i,
+  /(?:remember to|don't forget to|make sure to) (.{20,100})/i,
+];
+
+// Category detection based on content
+const CATEGORY_PATTERNS = [
+  { pattern: /agent|kenji|dmitri|giuseppe|helga|alejandro|viktor/i, category: 'agent' },
+  { pattern: /skill|pattern|template/i, category: 'skill' },
+  { pattern: /workflow|field|phase|activity/i, category: 'workflow' },
+  { pattern: /bug|error|fix|broken/i, category: 'bug' },
+  { pattern: /hook|guard|check/i, category: 'hook' },
+];
+
+// Read hook input from stdin
+let input = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', chunk => input += chunk);
+process.stdin.on('end', () => {
+  try {
+    const data = JSON.parse(input);
+    processHook(data);
+  } catch (e) {
+    console.error(`[auto-learn] Warning: ${e.message}`);
+    process.exit(0);
+  }
+});
+
+function detectCategory(text) {
+  for (const { pattern, category } of CATEGORY_PATTERNS) {
+    if (pattern.test(text)) {
+      return category;
+    }
+  }
+  return 'pattern';
+}
+
+function extractLearnings(text) {
+  const learnings = [];
+
+  // Limit input size to prevent ReDoS attacks (100KB max)
+  const MAX_INPUT_SIZE = 100000;
+  if (text.length > MAX_INPUT_SIZE) {
+    text = text.substring(0, MAX_INPUT_SIZE);
+  }
+
+  // Normalize whitespace for multi-line matching
+  const normalizedText = text.replace(/\s+/g, ' ');
+
+  // NOTE: Uses global match then per-result extraction. Acceptable for typical agent output sizes (<100KB).
+  // For larger inputs, consider exec() loop instead.
+  const matchStartTime = Date.now();
+  for (const pattern of LEARNING_PATTERNS) {
+    if (Date.now() - matchStartTime > 1000) break; // ReDoS timeout protection
+    // Use 'gis' flags for case-insensitive, dotall (multi-line) matching
+    const matches = normalizedText.match(new RegExp(pattern.source, 'gis'));
+    if (matches) {
+      for (const match of matches) {
+        const extracted = match.match(new RegExp(pattern.source, 'is'));
+        if (extracted && extracted[1]) {
+          let learning = extracted[1].trim();
+          learning = learning.replace(/\s+/g, ' ').replace(/[.!,;]$/, '').trim();
+          if (learning.length >= 20 && !learnings.some(l => l.text === learning)) {
+            learnings.push({
+              text: learning,
+              category: detectCategory(learning)
+            });
+          }
+        }
+      }
+    }
+  }
+
+  return learnings;
+}
+
+function processHook(data) {
+  const { tool_name, tool_input, tool_response } = data;
+
+  // Only process Task completions
+  if (tool_name !== 'Task') {
+    process.exit(0);
+  }
+
+  if (tool_response === undefined) {
+    process.exit(0);
+  }
+
+  const agentName = tool_input?.subagent_type;
+  const responseText = typeof tool_response === 'string'
+    ? tool_response
+    : JSON.stringify(tool_response || '');
+
+  const learnings = extractLearnings(responseText);
+
+  if (learnings.length > 0) {
+    // Save pending learnings for later confirmation
+    fs.writeFileSync(PENDING_FILE, JSON.stringify({
+      learnings,
+      agentName,
+      timestamp: new Date().toISOString()
+    }));
+
+    // Build options for AskUserQuestion (max 4)
+    const options = learnings.slice(0, 3).map((l, i) => ({
+      label: `Save #${i + 1}`,
+      description: l.text.substring(0, 50) + (l.text.length > 50 ? '...' : '')
+    }));
+    options.push({ label: 'Skip all', description: 'Don\'t save any of these' });
+
+    const output = `
+<user-prompt-submit-hook>
+📚 POTENTIAL LEARNING${learnings.length > 1 ? 'S' : ''} DETECTED
+
+${learnings.map((l, i) => `${i + 1}. [${l.category}] ${l.text}`).join('\n')}
+
+👉 Ask user: "Save to inbox/learnings.md?" Options: ${options.map(o => o.label).join(' / ')}
+
+If yes, run: node .claude/hooks/auto-learn.cjs --save <indices>
+</user-prompt-submit-hook>
+`;
+
+    console.log(output);
+  }
+
+  process.exit(0);
+}
+
+// CLI: Save specific learnings by index
+if (process.argv[2] === '--save') {
+  const indices = process.argv.slice(3)
+    .map(n => parseInt(n, 10))
+    .filter(n => !isNaN(n))
+    .map(n => n - 1);
+
+  if (!fs.existsSync(PENDING_FILE)) {
+    console.error('No pending learnings found');
+    process.exit(1);
+  }
+
+  const pending = JSON.parse(fs.readFileSync(PENDING_FILE, 'utf8'));
+  const toSave = indices
+    .filter(i => i >= 0 && i < pending.learnings.length)
+    .map(i => pending.learnings[i]);
+
+  if (toSave.length === 0) {
+    console.log('No valid learnings selected');
+    process.exit(0);
+  }
+
+  // Ensure LEARNINGS.md exists (recursive: true is idempotent, no TOCTOU race)
+  if (!fs.existsSync(LEARNINGS_FILE)) {
+    const dir = path.dirname(LEARNINGS_FILE);
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(LEARNINGS_FILE, `# Inbox
+
+Learnings captured from all projects. Review and integrate into marketplace agents/skills.
+
+## Pending
+<!-- /learn and auto-learn add items here -->
+
+## Applied
+<!-- Move items here after integrating into agents/skills -->
+`);
+  }
+
+  let content = fs.readFileSync(LEARNINGS_FILE, 'utf8');
+  const timestamp = new Date().toISOString().split('T')[0];
+
+  const entries = toSave.map(l => {
+    const source = pending.agentName ? `from ${pending.agentName}` : '';
+    const autoTag = '🤖 auto-learn';
+    return `- [${l.category}] ${l.text} _(${autoTag}${source ? `, ${source}` : ''}, ${timestamp})_`;
+  }).join('\n');
+
+  // Add under Pending section
+  const pendingMatch = content.match(/^(## Pending\s*\n(?:<!--[^>]*-->\s*\n)?)/m);
+  if (pendingMatch) {
+    const insertPoint = content.indexOf(pendingMatch[0]) + pendingMatch[0].length;
+    content = content.slice(0, insertPoint) + entries + '\n' + content.slice(insertPoint);
+  } else {
+    // Fallback: append to end if no Pending section found
+    content += `\n## Pending\n${entries}\n`;
+  }
+
+  // Atomic write: temp file + rename to prevent corruption
+  const tmpFile = LEARNINGS_FILE + '.tmp-' + process.pid;
+  fs.writeFileSync(tmpFile, content);
+  fs.renameSync(tmpFile, LEARNINGS_FILE);
+
+  // Safe unlink: ignore ENOENT if file already deleted
+  try {
+    fs.unlinkSync(PENDING_FILE);
+  } catch (err) {
+    if (err.code !== 'ENOENT') throw err;
+  }
+
+  console.log(`✅ Saved ${toSave.length} learning(s) to inbox/learnings.md`);
+  process.exit(0);
+}
+
+// CLI: Clear pending
+if (process.argv[2] === '--clear') {
+  if (fs.existsSync(PENDING_FILE)) {
+    fs.unlinkSync(PENDING_FILE);
+    console.log('✅ Cleared pending learnings');
+  } else {
+    console.log('No pending learnings');
+  }
+  process.exit(0);
+}
+
+// CLI: Show pending
+if (process.argv[2] === '--pending') {
+  if (!fs.existsSync(PENDING_FILE)) {
+    console.log('No pending learnings');
+    process.exit(0);
+  }
+  const pending = JSON.parse(fs.readFileSync(PENDING_FILE, 'utf8'));
+  console.log('Pending learnings:');
+  pending.learnings.forEach((l, i) => {
+    console.log(`  ${i + 1}. [${l.category}] ${l.text}`);
+  });
+  process.exit(0);
+}
+
+// CLI: Test
+if (process.argv[2] === '--test' && process.argv[3]) {
+  const text = process.argv.slice(3).join(' ');
+  const learnings = extractLearnings(text);
+  if (learnings.length === 0) {
+    console.log('No learnings detected');
+  } else {
+    console.log('Detected:');
+    learnings.forEach(l => console.log(`  [${l.category}] ${l.text}`));
+  }
+  process.exit(0);
+}
+
+// CLI: Help
+if (process.argv[2] === '--help' || process.argv[2] === '-h') {
+  console.log(`
+Auto-Learn Hook - Detects learnings and prompts for confirmation
+
+Usage:
+  node auto-learn.cjs --save 1 2 3   Save learnings by index
+  node auto-learn.cjs --pending      Show pending learnings
+  node auto-learn.cjs --clear        Clear pending learnings
+  node auto-learn.cjs --test <text>  Test detection on sample text
+  node auto-learn.cjs --help         Show this help
+
+Workflow:
+  1. Hook detects learning in agent response
+  2. Prompts Claude to ask user for confirmation
+  3. User selects which to save
+  4. Claude runs --save with indices
+
+Complements manual /learn command.
+`);
+  process.exit(0);
+}

package/.claude/hooks/bash-guard.cjs

@@ -0,0 +1,282 @@
+#!/usr/bin/env node
+/**
+ * <hook-name>bash-guard</hook-name>
+ *
+ * <purpose>
+ * Consolidated Bash PreToolUse guard. Replaces 4 separate hooks:
+ * - destructive-command-guard (blocks dangerous commands)
+ * - mcp-server-guard (blocks server start commands)
+ * - workspace-pull-guard (warns before pull with dirty workspace)
+ * - workspace-auto-save (auto-commits before push)
+ *
+ * Single Node process instead of 4 = faster, no timeouts.
+ * </purpose>
+ *
+ * <triggers>PreToolUse on Bash</triggers>
+ * @version 1.0.0
+ */
+
+const { spawnSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const ALLOW = JSON.stringify({ decision: 'allow' });
+const projectDir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+
+// --- CLI modes ---
+if (process.argv[2] === '--bypass' && process.argv[3]) {
+  const command = process.argv[3];
+  const bypass = { command, createdAt: Date.now(), expiresAt: Date.now() + 120000 };
+  const BYPASS_FILE = path.join(os.tmpdir(), '.claude-destructive-bypass.json');
+  const tmpFile = BYPASS_FILE + '.tmp-' + process.pid;
+  fs.writeFileSync(tmpFile, JSON.stringify(bypass, null, 2));
+  fs.renameSync(tmpFile, BYPASS_FILE);
+  console.log(`Bypass created for: ${command}`);
+  console.log('Expires in 2 minutes. Retry the command now.');
+  process.exit(0);
+}
+if (process.argv[2] === '--history') {
+  try {
+    const result = spawnSync('git', ['log', '--oneline', '--grep=Auto-save workspace', '-20'], {
+      cwd: projectDir, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe']
+    });
+    console.log((result.stdout || '').trim() || 'No auto-saves found');
+  } catch { console.log('Could not read git log'); }
+  process.exit(0);
+}
+if (process.argv[2] === '--help' || process.argv[2] === '-h') {
+  console.log(`
+Bash Guard - Consolidated Bash PreToolUse hook
+
+Combines: destructive-command-guard, mcp-server-guard, workspace-pull-guard, workspace-auto-save
+
+Usage:
+  node bash-guard.cjs --bypass '<cmd>'  Create one-time bypass for blocked command
+  node bash-guard.cjs --history         Show recent workspace auto-saves
+  node bash-guard.cjs --help            Show this help
+`);
+  process.exit(0);
+}
+
+// --- Yolo mode check ---
+let isYolo = false;
+try {
+  const statePath = path.join(projectDir, '.claude', 'yolo-state.json');
+  const state = JSON.parse(fs.readFileSync(statePath, 'utf8'));
+  isYolo = state.mode === 'yolo';
+} catch {}
+
+// --- Read stdin ---
+let input = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', chunk => input += chunk);
+process.stdin.on('end', () => {
+  try {
+    const data = JSON.parse(input || '{}');
+    processHook(data);
+  } catch {
+    allow();
+  }
+});
+
+function allow(msg) {
+  if (msg) console.error('[bash-guard] ' + msg);
+  console.log(ALLOW);
+  process.exit(0);
+}
+
+function block(reason) {
+  console.log(JSON.stringify({ decision: 'block', reason }));
+  process.exit(0);
+}
+
+function processHook(data) {
+  const { tool_name, tool_input } = data;
+  if (tool_name !== 'Bash') { allow(); return; }
+
+  const command = tool_input?.command || '';
+  if (!command) { allow(); return; }
+
+  // Run checks in order of specificity
+  if (!isYolo) {
+    checkDestructive(command);
+    checkMcpServer(command);
+    checkWorkspacePull(command);
+    checkWorkspaceAutoSave(command);
+  }
+  allow();
+}
+
+// ============================================================
+// 1. Destructive Command Guard
+// ============================================================
+const DANGEROUS_PATTERNS = [
+  { pattern: /git\s+reset\s+--hard/i, name: 'git reset --hard', risk: 'Permanently discards all uncommitted changes', alternative: 'git stash or git reset --soft' },
+  { pattern: /git\s+clean\s+-[fd]/i, name: 'git clean -f/-fd', risk: 'Permanently deletes untracked files', alternative: 'git clean -n (dry run)' },
+  { pattern: /\brm\s+-[a-zA-Z]{0,10}(rf|fr)[a-zA-Z]{0,10}\b/i, name: 'rm -rf', risk: 'Recursively deletes files without confirmation', alternative: 'rm -ri (interactive) or move to trash' },
+  { pattern: /git\s+push\s+[^|]*--force(?!-with-lease)[^|]*(main|master)/i, name: 'git push --force to main/master', risk: 'Overwrites remote history', alternative: 'git push --force-with-lease' },
+  { pattern: /git\s+push\s+[^|]*(main|master)[^|]*--force(?!-with-lease)/i, name: 'git push --force to main/master', risk: 'Overwrites remote history', alternative: 'git push --force-with-lease' },
+  { pattern: /git\s+checkout\s+\.\s*$/i, name: 'git checkout .', risk: 'Discards all uncommitted changes', alternative: 'git stash or git diff' },
+  { pattern: /git\s+restore\s+\.\s*$/i, name: 'git restore .', risk: 'Discards all uncommitted changes', alternative: 'git stash or git diff' },
+  { pattern: /git\s+branch\s+-D/, name: 'git branch -D', risk: 'Force-deletes branch even if not merged', alternative: 'git branch -d (safe delete)' }
+];
+
+const BYPASS_FILE = path.join(os.tmpdir(), '.claude-destructive-bypass.json');
+
+function isSubagentActive() {
+  try {
+    const stackFile = path.join(os.tmpdir(), '.claude-agent-stack.json');
+    if (fs.existsSync(stackFile)) {
+      const stack = JSON.parse(fs.readFileSync(stackFile, 'utf8'));
+      return Array.isArray(stack.agents) && stack.agents.length > 0;
+    }
+  } catch {}
+  return false;
+}
+
+function checkBypass(command) {
+  try {
+    const bypass = JSON.parse(fs.readFileSync(BYPASS_FILE, 'utf8'));
+    if (typeof bypass.expiresAt !== 'number' || typeof bypass.command !== 'string') {
+      try { fs.unlinkSync(BYPASS_FILE); } catch {}
+      return false;
+    }
+    if (bypass.expiresAt <= Date.now()) {
+      try { fs.unlinkSync(BYPASS_FILE); } catch {}
+      return false;
+    }
+    if (bypass.command === command) {
+      try { fs.unlinkSync(BYPASS_FILE); } catch {}
+      return true;
+    }
+  } catch {}
+  return false;
+}
+
+function checkDestructive(command) {
+  if (isSubagentActive()) return;
+  if (command.includes('bash-guard') && command.includes('--bypass')) return;
+  if (checkBypass(command)) return;
+
+  for (const { pattern, name, risk, alternative } of DANGEROUS_PATTERNS) {
+    if (pattern.test(command)) {
+      block(`BLOCKED: Destructive Command Detected
+
+**Command:** \`${name}\`
+**Risk:** ${risk}
+
+**USE THESE INSTEAD (no bypass needed):**
+- Delete files individually: \`rm file1 file2\` (no -rf flag)
+- Delete directory contents: \`find /path -mindepth 1 -delete\`
+- Move to trash: \`mv /path ~/.Trash/\`
+- Safe alternative: ${alternative}
+
+**ONLY if user explicitly requests the destructive command:**
+1. Ask user with AskUserQuestion
+2. Run: Bash: node "${process.argv[1].replace(/'/g, "'\\''")}" --bypass '${command.replace(/'/g, "'\\''")}'
+3. Retry the original command`);
+    }
+  }
+}
+
+// ============================================================
+// 2. MCP Server Guard
+// ============================================================
+const SERVER_START_PATTERNS = [
+  /npm run dev\b/, /npm run start\b/, /npm start\b/,
+  /tsx\s+.*src\/app\.ts/, /tsx\s+watch\s+.*src\/app\.ts/,
+  /node\s+.*src\/app\.ts/, /node\s+.*dist\/app\.js/,
+  /npx\s+tsx\s+.*src\/app/
+];
+
+function checkMcpServer(command) {
+  if (!SERVER_START_PATTERNS.some(p => p.test(command))) return;
+
+  block(`MCP server commands are blocked. Tell the user to run manually:
+  cd ${projectDir} && npm run dev`);
+}
+
+// ============================================================
+// 3. Workspace Pull Guard
+// ============================================================
+function checkWorkspacePull(command) {
+  if (!command.match(/npm\s+run\s+pull/)) return;
+  if (process.env.CLAUDE_AGENT_ID || process.env.CLAUDE_SUBAGENT) return;
+
+  const workspaceDir = path.join(projectDir, 'workspace');
+  if (!fs.existsSync(workspaceDir)) { invalidateSharedMemory(); return; }
+
+  try {
+    const result = spawnSync('git', ['status', '--porcelain', 'workspace/'], {
+      cwd: projectDir, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe']
+    });
+    const status = (result.stdout || '').trim();
+
+    if (status) {
+      const changedFiles = status.split('\n').map(l => l.trim()).filter(Boolean);
+      block(`BLOCKED: Uncommitted changes in workspace/
+
+\`npm run pull\` will OVERWRITE your local TypeScript files!
+
+**Changed files:**
+${changedFiles.map(f => '  ' + f).join('\n')}
+
+Options:
+1. Push first: npm run push → npm run pull
+2. Save first: /save "WIP before pull" → npm run pull
+3. Discard: git checkout -- workspace/ → npm run pull`);
+    }
+    invalidateSharedMemory();
+  } catch {
+    invalidateSharedMemory();
+  }
+}
+
+// ============================================================
+// 4. Workspace Auto-Save
+// ============================================================
+const PUSH_PATTERNS = [
+  /npm\s+run\s+.*push/, /npm\s+run\s+.*sync/,
+  /workflows-sync/, /fields-push/, /phases-push/,
+  /insights-push/, /templates-sync/
+];
+
+function checkWorkspaceAutoSave(command) {
+  if (!PUSH_PATTERNS.some(p => p.test(command))) return;
+
+  const workspaceDir = path.join(projectDir, 'workspace');
+  if (!fs.existsSync(workspaceDir)) return;
+
+  try {
+    const result = spawnSync('git', ['status', '--porcelain', 'workspace/'], {
+      cwd: projectDir, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe']
+    });
+    const status = (result.stdout || '').trim();
+    if (!status) { console.error('[bash-guard] workspace/ clean, no auto-save needed'); return; }
+
+    const changes = status.split('\n').filter(Boolean).length;
+    const timestamp = new Date().toISOString().slice(0, 19).replace('T', ' ').replace(/[:.]/g, '-');
+    spawnSync('git', ['add', 'workspace/'], { cwd: projectDir, encoding: 'utf8' });
+    const commitResult = spawnSync('git', ['commit', '-m', `Auto-save workspace before push (${timestamp})`], {
+      cwd: projectDir, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe']
+    });
+    if (commitResult.status !== 0 && !commitResult.stderr?.includes('nothing to commit')) {
+      throw new Error(commitResult.stderr || 'git commit failed');
+    }
+    console.error('[bash-guard] Auto-saved ' + changes + ' workspace change(s) before push');
+  } catch (err) {
+    console.error('[bash-guard] Could not auto-save: ' + err.message);
+  }
+}
+
+// ============================================================
+// Shared memory invalidation (after pull)
+// ============================================================
+function invalidateSharedMemory() {
+  try {
+    const mem = require('./_shared-memory.cjs');
+    mem.invalidate();
+    console.error('[bash-guard] Shared memory invalidated (workspace pull).');
+  } catch {}
+}