@matt82198/aesop 0.1.0-beta.3 → 0.1.0-beta.5

package/monitor/collect-signals.mjs

@@ -4,40 +4,121 @@
 
 import fs from 'node:fs';
 import path from 'node:path';
-import { execSync, spawnSync } from 'node:child_process';
+import os from 'node:os';
+import { execSync, execFileSync, spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { acquireLock, releaseLock } from '../tools/lock.mjs';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
 
 // === Configuration ===
-// Load from environment or aesop.config.json; fall back to safe defaults.
+// Helper: load aesop.config.json if it exists
+function loadConfigFile(aesopRoot) {
+  try {
+    const configPath = path.join(aesopRoot, 'aesop.config.json');
+    if (fs.existsSync(configPath)) {
+      return JSON.parse(fs.readFileSync(configPath, 'utf8'));
+    }
+  } catch {
+    // Parse error or file doesn't exist; ignore
+  }
+  return {};
+}
+
+// Helper: expand ~ and environment variables in paths for portability
+function expandPath(pathStr) {
+  if (!pathStr) return pathStr;
+  // Expand ~ to home directory
+  if (pathStr.startsWith('~')) {
+    return path.join(os.homedir(), pathStr.slice(1));
+  }
+  // Expand environment variables like $VAR or %VAR%
+  return pathStr.replace(/\$\{?([A-Z_]+)\}?/gi, (match, varName) => {
+    return process.env[varName] || match;
+  });
+}
+
+// Precedence: env var > config file > built-in default
 const AESOP_ROOT = process.env.AESOP_ROOT || '.';
-const BRAIN_ROOT = process.env.BRAIN_ROOT || path.join(AESOP_ROOT, '..', '.claude');
-const SCRIPTS_ROOT = process.env.SCRIPTS_ROOT || path.join(AESOP_ROOT, '..', 'scripts');
-const TEMP_ROOT = process.env.TEMP_ROOT || path.join(AESOP_ROOT, '..', 'AppData', 'Local', 'Temp', 'claude');
+const config = loadConfigFile(AESOP_ROOT);
+
+const BRAIN_ROOT = expandPath(
+  process.env.BRAIN_ROOT ||
+  config.brain_root ||
+  path.join(AESOP_ROOT, '..', '.claude')
+);
+
+const SCRIPTS_ROOT = expandPath(
+  process.env.SCRIPTS_ROOT ||
+  config.scripts_root ||
+  path.join(AESOP_ROOT, '..', 'scripts')
+);
+
+const TEMP_ROOT = expandPath(
+  process.env.TEMP_ROOT ||
+  config.temp_root ||
+  path.join(os.tmpdir(), 'claude')
+);
+
+const STATE_DIR = expandPath(
+  process.env.AESOP_STATE_ROOT ||
+  config.state_root ||
+  path.join(AESOP_ROOT, 'state')
+);
+
 const MON = path.join(AESOP_ROOT, 'monitor');
-const STATE_DIR = path.join(AESOP_ROOT, 'state');
 
-// Optional: load aesop.config.json for repo list
+// Config-driven thresholds and feature flags
 let repos = [];
 let logThresholds = { maxLines: 500, maxKb: 40 };
-try {
-  const configPath = path.join(AESOP_ROOT, 'aesop.config.json');
-  const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
-  if (config.repos && Array.isArray(config.repos)) {
-    repos = config.repos.map(r => r.path);
-  }
-  if (config.monitor && config.monitor.log_max_lines) {
-    logThresholds.maxLines = config.monitor.log_max_lines;
-  }
-  if (config.monitor && config.monitor.log_max_kb) {
-    logThresholds.maxKb = config.monitor.log_max_kb;
-  }
-} catch {
-  // No config file or parse error; use defaults
+let extendedSignals = false;
+
+if (config.repos && Array.isArray(config.repos)) {
+  repos = config.repos.map(r => r.path);
 }
+if (config.monitor && config.monitor.log_max_lines) {
+  logThresholds.maxLines = config.monitor.log_max_lines;
+}
+if (config.monitor && config.monitor.log_max_kb) {
+  logThresholds.maxKb = config.monitor.log_max_kb;
+}
+
+// Precedence: env > config > default
+// AESOP_EXTENDED_SIGNALS env var takes precedence
+if (process.env.AESOP_EXTENDED_SIGNALS !== undefined) {
+  extendedSignals = process.env.AESOP_EXTENDED_SIGNALS === 'true' || process.env.AESOP_EXTENDED_SIGNALS === '1';
+} else if (config.monitor && config.monitor.extended_signals !== undefined) {
+  extendedSignals = config.monitor.extended_signals;
+}
+// else default is false (already set above)
 
 const now = Date.now();
 const HOUR = 3600e3;
 const DAY = 24 * HOUR;
 
+// === Single-instance guard: check own heartbeat at startup ===
+// If heartbeat is <300s old and AESOP_MONITOR_FORCE is not explicitly set to 'true' or '1', skip this cycle
+// (another instance is running). Match the AESOP_EXTENDED_SIGNALS truthiness pattern.
+if (process.env.AESOP_MONITOR_FORCE !== 'true' && process.env.AESOP_MONITOR_FORCE !== '1') {
+  const heartbeatPath = path.join(MON, '.monitor-heartbeat');
+  try {
+    const content = fs.readFileSync(heartbeatPath, 'utf8').trim();
+    const epoch = parseInt(content.split('\n')[0], 10);
+    if (epoch) {
+      const beatAge = now - epoch * 1000;
+      const MONITOR_THRESHOLD = 300e3; // 300 seconds
+      if (beatAge < MONITOR_THRESHOLD) {
+        // Heartbeat is recent; another instance is running. Skip this cycle.
+        console.log(`[skip] Monitor already running (heartbeat: ${(beatAge / 1000).toFixed(0)}s ago, threshold: ${MONITOR_THRESHOLD / 1000}s)`);
+        process.exit(0);
+      }
+    }
+  } catch {
+    // Heartbeat file doesn't exist or is unreadable; proceed with cycle
+  }
+}
+
 // === Utilities ===
 const sh = (cmd, cwd) => {
   try {
@@ -87,7 +168,13 @@ const walk = (dir, test, out = [], depth = 0) => {
 function checkHeartbeats() {
   const staleLoops = [];
   const beatsDir = path.join(MON, '.heartbeats');
-  const thresholds = { watchdog: 300e3, monitor: 3600e3, default: 1800e3 };
+  // Load thresholds from config or use defaults (in seconds; convert to milliseconds)
+  const hbThresholds = (config.monitor && config.monitor.heartbeat_thresholds) || {};
+  const thresholds = {
+    watchdog: (hbThresholds.watchdog !== undefined ? hbThresholds.watchdog : 300) * 1000,
+    monitor: (hbThresholds.monitor !== undefined ? hbThresholds.monitor : 3600) * 1000,
+    default: (hbThresholds.default !== undefined ? hbThresholds.default : 1800) * 1000,
+  };
   let beatFiles = [];
   try {
     beatFiles = fs.readdirSync(beatsDir).map(f => path.join(beatsDir, f));
@@ -242,6 +329,8 @@ function detectJunkScripts() {
       .slice(0, 8)
       .map(x => `${age(x.ageMs)} ${x.fp.split(/[/\\]/).slice(-2).join('/')}`),
     recentCount: tempScripts.filter(x => now - x.ageMs < HOUR).length,
+    // Store all temp scripts for AUTO quarantine action
+    _scripts: tempScripts,
   };
   return junk;
 }
@@ -319,11 +408,27 @@ function detectRespawnWatch() {
 function trackCostCadence() {
   const prevStateFile = path.join(MON, '.signal-state.json');
   let prevState = {};
-  try {
-    prevState = JSON.parse(fs.readFileSync(prevStateFile, 'utf8'));
-  } catch {
-    // no prev state
+
+  // Check file existence first; don't silently fail on parse errors
+  if (fs.existsSync(prevStateFile)) {
+    try {
+      prevState = JSON.parse(fs.readFileSync(prevStateFile, 'utf8'));
+    } catch (e) {
+      // Parse failure: log warning and preserve a .corrupt copy for evidence
+      console.error(`Warning: Failed to parse .signal-state.json: ${e.message}`);
+      try {
+        const corruptPath = prevStateFile + '.corrupt';
+        const content = fs.readFileSync(prevStateFile, 'utf8');
+        fs.writeFileSync(corruptPath, content, 'utf8');
+        console.error(`Corrupt state preserved to ${corruptPath}`);
+      } catch (copyErr) {
+        console.error(`Failed to preserve corrupt state: ${copyErr.message}`);
+      }
+      // Reset to empty state and continue (graceful recovery)
+      prevState = {};
+    }
   }
+
   const cycleCount = (prevState.cycleCount || 0) + 1;
   let costTick = null;
   if (cycleCount % 3 === 0) {
@@ -350,17 +455,311 @@ function checkUnreviewedPrompts() {
   return 0;
 }
 
+// 11) Isolation violation detection (rec #5: git-tracked dirs don't flag)
+// Detects worktrees created INSIDE repo root (violation) vs sanctioned ../sibling-wt-* (OK)
+// FP fix: git-tracked source directories (new modules) do NOT flag as violations
+function detectIsolationViolations() {
+  if (!fs.existsSync(AESOP_ROOT)) return { violations: [], count: 0 };
+
+  const violations = [];
+  const trackedFiles = new Set();
+
+  // Get list of git-tracked files to exclude legitimate source dirs
+  try {
+    const tracked = sh('git ls-files', AESOP_ROOT);
+    tracked.split('\n').forEach(f => {
+      if (f) {
+        const dir = f.split('/')[0];
+        trackedFiles.add(dir);
+      }
+    });
+  } catch {
+    // If git ls-files fails, proceed without tracked set (less precise but fail-open)
+  }
+
+  // Walk AESOP_ROOT (shallow) looking for dirs with nested .git
+  try {
+    const entries = fs.readdirSync(AESOP_ROOT, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      if (entry.name.startsWith('.')) continue;
+      if (entry.name === 'node_modules') continue;
+
+      const dirPath = path.join(AESOP_ROOT, entry.name);
+      const gitPath = path.join(dirPath, '.git');
+
+      // Check if this directory has a .git file or .git dir (worktree indicator)
+      try {
+        const gitStat = fs.statSync(gitPath);
+        // It has .git — check if it's a worktree (contains "gitdir:" or is a symlink)
+        const isWorktree = gitStat.isFile() || gitStat.isSymbolicLink();
+
+        if (isWorktree) {
+          // This looks like a worktree. Check if it's git-tracked (FP fix)
+          const isTracked = trackedFiles.has(entry.name);
+
+          if (!isTracked) {
+            // Untracked worktree inside repo root = VIOLATION
+            violations.push({
+              path: entry.name,
+              type: 'untracked-worktree-in-root',
+              message: `Worktree '${entry.name}' found inside repo root (untracked). Should use sanctioned ../aesop-wt-* sibling instead.`,
+            });
+          }
+          // If tracked, it's a legitimate source directory; don't flag
+        }
+      } catch (e) {
+        // Entry doesn't have .git or is inaccessible; skip
+      }
+    }
+  } catch (e) {
+    // Directory read failed; fail-open with no violations
+  }
+
+  return { violations, count: violations.length };
+}
+
+// === AUTO Actions ===
+// Log rotation: invoke rotate_logs.py if available and log needs rotation
+function performAutoLogRotation(logFiles, actionsLogPath) {
+  // rotate_logs.py is in tools directory (sibling to monitor)
+  let rotateLogsPy = path.join(path.dirname(MON), 'tools', 'rotate_logs.py');
+
+  // Fallback: look in SCRIPTS_ROOT if not found in tools
+  if (!fs.existsSync(rotateLogsPy)) {
+    rotateLogsPy = path.join(SCRIPTS_ROOT, 'rotate_logs.py');
+  }
+
+  // Fallback: look in the actual aesop source directory (for tests/CI environments)
+  if (!fs.existsSync(rotateLogsPy)) {
+    // Try to find the real aesop tools directory by looking for the real monitor/CHARTER.md
+    const realMonitorCharter = path.join(__dirname, 'CHARTER.md');
+    if (fs.existsSync(realMonitorCharter)) {
+      rotateLogsPy = path.join(__dirname, '..', 'tools', 'rotate_logs.py');
+    }
+  }
+
+  if (!fs.existsSync(rotateLogsPy)) {
+    // rotate_logs.py not available; skip (fail-open per CHARTER.md)
+    return [];
+  }
+
+  const rotatedLogs = [];
+  const logsNeedingRotation = logFiles.filter(l => l.needsRotation);
+
+  for (const log of logsNeedingRotation) {
+    if (!log.exists) continue;
+    let logPath;
+    if (log.name === 'ACTIONS.log') {
+      logPath = path.join(MON, log.name);
+    } else {
+      logPath = log.name.startsWith('/') ? log.name : path.join(STATE_DIR, log.name);
+    }
+
+    try {
+      // Invoke rotate_logs.py with thresholds from config
+      // Use execFileSync instead of execSync for command injection protection (no shell)
+      execFileSync('python', [
+        rotateLogsPy,
+        logPath,
+        '--max-lines',
+        String(logThresholds.maxLines),
+        '--max-bytes',
+        String(Math.floor(logThresholds.maxKb * 1024)),
+      ], { stdio: ['ignore', 'pipe', 'pipe'] });
+      rotatedLogs.push(log.name);
+
+      // Log the AUTO action
+      const timestamp = new Date(now).toISOString();
+      fs.appendFileSync(actionsLogPath, `[${timestamp}] AUTO action: Log rotation invoked for ${log.name}\n`, 'utf8');
+    } catch (e) {
+      // Log rotation failed; fail-open (log the error but continue)
+      const timestamp = new Date(now).toISOString();
+      fs.appendFileSync(actionsLogPath, `[${timestamp}] AUTO action FAILED: Log rotation for ${log.name}: ${e.message}\n`, 'utf8');
+    }
+  }
+
+  return rotatedLogs;
+}
+
+// Junk quarantine: move old temp scripts to monitor/quarantine/ with manifest
+function performAutoJunkQuarantine(junkScripts, quarantineDir, manifestPath) {
+  if (!Array.isArray(junkScripts) || junkScripts.length === 0) {
+    return { quarantined: 0 };
+  }
+
+  let quarantinedCount = 0;
+  const manifestLines = [];
+
+  // Read existing manifest if it exists
+  let existingManifest = '';
+  if (fs.existsSync(manifestPath)) {
+    try {
+      existingManifest = fs.readFileSync(manifestPath, 'utf8');
+    } catch {
+      // Ignore read errors
+    }
+  }
+
+  // Create quarantine directory if needed
+  try {
+    fs.mkdirSync(quarantineDir, { recursive: true });
+  } catch {
+    // Directory creation failed; skip quarantine
+    return { quarantined: 0 };
+  }
+
+  // Quarantine each old junk script
+  for (const junkItem of junkScripts) {
+    if (junkItem.quarantinable && fs.existsSync(junkItem.fp)) {
+      try {
+        const basename = path.basename(junkItem.fp);
+        const quarantinePath = path.join(quarantineDir, basename);
+
+        // Copy (not move) to quarantine to avoid issues with long paths or multiple instances
+        fs.copyFileSync(junkItem.fp, quarantinePath);
+
+        // Record in manifest
+        const timestamp = new Date(now).toISOString();
+        const manifestLine = `${timestamp}\t${basename}\t${junkItem.fp}\t${junkItem.size}\tbytes\n`;
+        manifestLines.push(manifestLine);
+
+        quarantinedCount++;
+      } catch (e) {
+        // Quarantine failed for this item; continue with others
+      }
+    }
+  }
+
+  // Append new entries to manifest
+  if (manifestLines.length > 0) {
+    try {
+      if (!existingManifest) {
+        // Write header
+        fs.writeFileSync(manifestPath, 'timestamp\tfilename\tsource_path\tsize_bytes\tunit\n', 'utf8');
+      }
+      fs.appendFileSync(manifestPath, manifestLines.join(''), 'utf8');
+    } catch {
+      // Manifest write failed; continue
+    }
+  }
+
+  return { quarantined: quarantinedCount };
+}
+
+// === Locking utilities (imported from tools/lock.mjs with fail-closed behavior) ===
+// acquireLock now throws on timeout (fail-closed) instead of proceeding unlocked (P0 wave-8 fix)
+// For emitProposal (monitor context), we wrap it to log errors and skip emission rather than crashing the cycle
+function safeAcquireLock(proposalsFile) {
+  try {
+    return acquireLock(proposalsFile);
+  } catch (e) {
+    // Lock acquisition failed; log error and return null
+    // Caller (emitProposal) will skip emission in this case
+    console.error(`Warning: ${e.message}; skipping proposal emission for this cycle`);
+    return null;
+  }
+}
+
+
+// === Proposal Emission ===
+// Append PROPOSE-tier signals to monitor/PROPOSALS.md (idempotent per signal key, with atomic locking)
+function emitProposal(signalKey, problem, suggestedChange) {
+  const proposalsPath = path.join(MON, 'PROPOSALS.md');
+  const timestamp = new Date(now).toISOString();
+
+  // Acquire lock before read-check-append
+  const lockDir = safeAcquireLock(proposalsPath);
+
+  // If lock acquisition failed (fail-closed), skip emission for this cycle
+  if (!lockDir) {
+    return;
+  }
+
+  try {
+    // Read existing proposals to check for duplicate
+    let existingContent = '';
+    try {
+      existingContent = fs.readFileSync(proposalsPath, 'utf8');
+    } catch {
+      // File doesn't exist yet; start fresh
+      if (!fs.existsSync(MON)) {
+        fs.mkdirSync(MON, { recursive: true });
+      }
+    }
+
+    // Check if this signal key already has an entry (idempotency check)
+    if (existingContent.includes(`**Signal:** ${signalKey}`)) {
+      // Entry already exists; skip to avoid duplicates
+      return;
+    }
+
+    // Append new proposal entry
+    const proposal = `
+## ${signalKey} — ${timestamp}
+
+**Signal:** ${signalKey}
+
+**Problem:**
+${problem}
+
+**Suggested change:**
+${suggestedChange}
+
+---
+`;
+
+    try {
+      fs.appendFileSync(proposalsPath, proposal, 'utf8');
+    } catch (e) {
+      // Fail-open: log to BRIEF instead of crashing
+      console.error(`Failed to write PROPOSALS.md: ${e.message}`);
+    }
+  } finally {
+    releaseLock(lockDir);
+  }
+}
+
 // === Main ===
 const staleLoops = checkHeartbeats();
 const gitState = checkGitState();
 const memory = checkMemoryFreshness();
 const logFiles = checkLogFiles();
-const junk = detectJunkScripts();
-const strayRepo = detectStrayRepoScripts();
+const isolationViolations = detectIsolationViolations();
+
+// Extended signal checks (5, 6, 8, 10) — skipped if extended_signals is OFF
+const junk = extendedSignals ? detectJunkScripts() : { skipped: true };
+const strayRepo = extendedSignals ? detectStrayRepoScripts() : { skipped: true };
+
 const alerts = checkSecurityAlerts();
-const respawnWatch = detectRespawnWatch();
+
+const respawnWatch = extendedSignals ? detectRespawnWatch() : { skipped: true };
 const { cycleCount, costTick } = trackCostCadence();
-const unreviewedPrompts = checkUnreviewedPrompts();
+const unreviewedPrompts = extendedSignals ? checkUnreviewedPrompts() : { skipped: true };
+
+// === Perform AUTO Actions ===
+// (Executed before emitting signals, so outputs reflect actions taken)
+const actionsLogPath = path.join(MON, 'ACTIONS.log');
+
+// Ensure MON directory and ACTIONS.log exist
+try {
+  fs.mkdirSync(MON, { recursive: true });
+  if (!fs.existsSync(actionsLogPath)) {
+    fs.writeFileSync(actionsLogPath, '', 'utf8');
+  }
+} catch {
+  // Ignore directory creation errors
+}
+
+// AUTO: Log rotation
+performAutoLogRotation(logFiles, actionsLogPath);
+
+// AUTO: Junk quarantine (only run if junk check was not skipped)
+const quarantineDir = path.join(MON, 'quarantine');
+const manifestPath = path.join(quarantineDir, 'MANIFEST.tsv');
+if (!junk.skipped && junk._scripts && junk.quarantinable > 0) {
+  performAutoJunkQuarantine(junk._scripts, quarantineDir, manifestPath);
+}
 
 const signals = {
   timestamp: new Date(now).toISOString(),
@@ -375,6 +774,7 @@ const signals = {
   respawnWatch,
   costTick,
   unreviewedPrompts,
+  isolationViolations,
 };
 
 const brief = [];
@@ -422,39 +822,60 @@ if (needsRotation.length === 0) {
 }
 brief.push('');
 
-brief.push('## Junk-script sprawl (temp/scratch)');
-brief.push(`- ${junk.total} total scripts, ${(junk.bytes / 1024).toFixed(0)}kb`);
-brief.push(`  Quarantinable (>24h, not live): ${junk.quarantinable}`);
-if (junk.oldest.length > 0) {
-  brief.push('  Oldest:');
-  for (const o of junk.oldest) {
-    brief.push(`    ${o}`);
+brief.push('## Isolation violations');
+if (isolationViolations.count === 0) {
+  brief.push('✓ No worktrees detected inside repo root (sanctioned siblings OK).');
+} else {
+  brief.push(`🚨 **${isolationViolations.count} isolation violation(s)** detected (worktrees inside repo root):`);
+  for (const v of isolationViolations.violations) {
+    brief.push(`  - ${v.path}: ${v.message}`);
   }
 }
-if (strayRepo.length > 0) {
-  brief.push('');
-  brief.push('## Stray repo scripts (7d)');
-  for (const s of strayRepo) {
-    brief.push(`- ${s}`);
+brief.push('');
+
+// Extended signals section (if disabled, just note they're off; if enabled, show details)
+if (extendedSignals) {
+  brief.push('## Junk-script sprawl (temp/scratch)');
+  brief.push(`- ${junk.total} total scripts, ${(junk.bytes / 1024).toFixed(0)}kb`);
+  brief.push(`  Quarantinable (>24h, not live): ${junk.quarantinable}`);
+  if (junk.oldest.length > 0) {
+    brief.push('  Oldest:');
+    for (const o of junk.oldest) {
+      brief.push(`    ${o}`);
+    }
+  }
+  if (strayRepo.length > 0) {
+    brief.push('');
+    brief.push('## Stray repo scripts (7d)');
+    for (const s of strayRepo) {
+      brief.push(`- ${s}`);
+    }
   }
+  brief.push('');
+} else {
+  brief.push('## Extended signal checks');
+  brief.push('Checks 5 (junk-script sprawl), 6 (stray-repo scripts), 8 (respawn-watch), 10 (unreviewed-prompts) are **extended (off)** — enable via `monitor.extended_signals: true` in aesop.config.json or `AESOP_EXTENDED_SIGNALS=true`.');
+  brief.push('');
 }
-brief.push('');
 
 brief.push('## Security');
 brief.push(`- Alert log: ${alerts.count} entries, ${alerts.highMedCount} HIGH/MED`);
 brief.push('');
 
-brief.push('## Respawn watch (Rule 6 retry cap)');
-if (respawnWatch.length === 0) {
-  brief.push('✓ No retry-cap breaches (all signatures ≤3 occurrences).');
-} else {
-  brief.push(`⚠ **${respawnWatch.length} signature(s) exceeded 3-attempt limit:**`);
-  for (const rw of respawnWatch) {
-    brief.push(`  - ${rw.warning}`);
+// Respawn watch (check 8 — extended)
+if (extendedSignals) {
+  brief.push('## Respawn watch (Rule 6 retry cap)');
+  if (respawnWatch.length === 0) {
+    brief.push('✓ No retry-cap breaches (all signatures ≤3 occurrences).');
+  } else {
+    brief.push(`⚠ **${respawnWatch.length} signature(s) exceeded 3-attempt limit:**`);
+    for (const rw of respawnWatch) {
+      brief.push(`  - ${rw.warning}`);
+    }
+    brief.push('  (Note: distinguish legitimate fan-outs from identical retries; manual review recommended.)');
   }
-  brief.push('  (Note: distinguish legitimate fan-outs from identical retries; manual review recommended.)');
+  brief.push('');
 }
-brief.push('');
 
 brief.push('## Cost tracking');
 brief.push(`- Cycle: ${cycleCount}${costTick ? ' — tick recorded' : ''}`);
@@ -463,21 +884,152 @@ if (costTick) {
 }
 brief.push('');
 
-brief.push('## Unreviewed prompts');
-brief.push(`- ${unreviewedPrompts} new prompt(s) awaiting semantic review`);
-brief.push('');
+// Unreviewed prompts (check 10 — extended)
+if (extendedSignals) {
+  brief.push('## Unreviewed prompts');
+  brief.push(`- ${unreviewedPrompts} new prompt(s) awaiting semantic review`);
+  brief.push('');
+}
 
 brief.push('_Refinement points → act per CHARTER.md (AUTO safe, PROPOSE rule changes). Goal is fixed._');
 
-// Write outputs
+// === Emit PROPOSE-tier proposals ===
+// Only emit for signals that warrant user review per CHARTER.md action tiers
+
+// Proposals for extended checks (only if extended_signals is ON)
+if (extendedSignals) {
+  if (respawnWatch.length > 0) {
+    emitProposal(
+      'respawn-watch-breach',
+      `Rule 6 retry cap breached: ${respawnWatch.length} agent signature(s) appeared >3 times in recent spawn history. This indicates either an intentional parallel fan-out or a hung-agent loop.`,
+      `Review FLEET-LEDGER.md to distinguish legitimate concurrent spawns from identical retries. If retries are unintentional, investigate root cause and add guardrails to prevent re-dispatch. Consider updating monitoring thresholds or retry strategy.`
+    );
+  }
+
+  if (strayRepo.length > 0) {
+    emitProposal(
+      'stray-repo-scripts',
+      `${strayRepo.length} script file(s) committed to repo root in past 7 days: ${strayRepo.join(', ')}. Scripts should live in dedicated src/ or scripts/ paths, not repo root.`,
+      `Move stray scripts to proper paths per project discipline. Update CONTRIBUTING.md if repo structure is ambiguous. Add pre-commit hook or CI check to enforce.`
+    );
+  }
+}
+
+// Core proposals (always emitted)
+if (isolationViolations.count > 0) {
+  emitProposal(
+    'isolation-violation-detected',
+    `${isolationViolations.count} worktree(s) detected inside repo root. Agents should create worktrees as sanctioned siblings (../aesop-wt-*), not inside the repo root to maintain isolation.`,
+    `Review the violation(s): ${isolationViolations.violations.map(v => v.path).join(', ')}. Move worktrees to ../aesop-wt-<name> location outside repo root. Add pre-commit hook or monitoring to prevent future in-root worktrees.`
+  );
+}
+
+if (alerts.highMedCount > 0) {
+  emitProposal(
+    'security-alerts-high-med',
+    `${alerts.highMedCount} HIGH/MED security alert(s) in SECURITY-ALERTS.log. These may indicate real vulnerabilities, credential exposure, or false positives requiring review.`,
+    `Review each HIGH/MED entry in SECURITY-ALERTS.log. Distinguish real issues (fix immediately) from false positives (mark SUPPRESSED-FP). Update scanning rules if needed to reduce noise.`
+  );
+}
+
+if (memory.staleCount > 0) {
+  emitProposal(
+    'stale-memory-files',
+    `${memory.staleCount} memory file(s) older than 30 days: ${memory.staleMemories.join(', ')}. Stale memory may indicate obsolete project context or abandoned projects.`,
+    `Review stale memory files in keeper. Consolidate, archive, or delete per project lifecycle. Update memory refresh schedule if projects are active but infrequently updated.`
+  );
+}
+
+// Helper: Atomic rename with EPERM/EBUSY retry and cleanup on failure
+function atomicRename(tmpPath, targetPath) {
+  const maxRetries = 5;
+  const baseDelayMs = 50;
+
+  for (let i = 0; i < maxRetries; i++) {
+    try {
+      fs.renameSync(tmpPath, targetPath);
+      return true; // Success
+    } catch (e) {
+      if ((e.code === 'EPERM' || e.code === 'EBUSY') && i < maxRetries - 1) {
+        // Retry on Windows EPERM or EBUSY (file held by reader)
+        const delayMs = baseDelayMs * (i + 1); // Exponential backoff: 50ms, 100ms, 150ms, 200ms
+        const start = Date.now();
+        while (Date.now() - start < delayMs) {
+          // Busy-wait to avoid scheduling overhead
+        }
+      } else {
+        // Final failure or non-retryable error; clean up .tmp file and return false
+        try {
+          fs.unlinkSync(tmpPath);
+        } catch {
+          // Cleanup failed; best effort
+        }
+        return false;
+      }
+    }
+  }
+
+  // Final failure after all retries; clean up and return false
+  try {
+    fs.unlinkSync(tmpPath);
+  } catch {
+    // Cleanup failed; best effort
+  }
+  return false;
+}
+
+// Write outputs atomically with per-file retry on EPERM
 try {
   fs.mkdirSync(MON, { recursive: true });
-  fs.writeFileSync(path.join(MON, 'BRIEF.md'), brief.join('\n'), 'utf8');
-  fs.writeFileSync(path.join(MON, 'SIGNALS.json'), JSON.stringify(signals, null, 2), 'utf8');
-  fs.writeFileSync(path.join(MON, '.monitor-heartbeat'), String(Math.floor(now / 1000)), 'utf8');
-  const summaryLine = `stale-loops: ${staleLoops.length}, repos-dirty: ${gitState.filter(g => g.dirty > 0).length}, stale-mem: ${memory.staleCount}, logs-need-rotation: ${needsRotation.length}, junk-quarantinable: ${junk.quarantinable}, stray-repo-scripts: ${strayRepo.length}, alerts-high-med: ${alerts.highMedCount}, respawn-watch: ${respawnWatch.length}, cycle: ${cycleCount}`;
+
+  // Atomic write for BRIEF.md: write to .tmp, then rename with retry
+  const briefPath = path.join(MON, 'BRIEF.md');
+  const briefTmpPath = briefPath + '.tmp';
+  let briefSuccess = false;
+  try {
+    fs.writeFileSync(briefTmpPath, brief.join('\n'), 'utf8');
+    briefSuccess = atomicRename(briefTmpPath, briefPath);
+    if (!briefSuccess) {
+      console.error(`Warning: Failed to write BRIEF.md after retries; keeping prior file`);
+    }
+  } catch (e) {
+    console.error(`Warning: Failed to write BRIEF.md: ${e.message}`);
+  }
+
+  // Atomic write for SIGNALS.json: write to .tmp, then rename with retry
+  const signalsPath = path.join(MON, 'SIGNALS.json');
+  const signalsTmpPath = signalsPath + '.tmp';
+  let signalsSuccess = false;
+  try {
+    fs.writeFileSync(signalsTmpPath, JSON.stringify(signals, null, 2), 'utf8');
+    signalsSuccess = atomicRename(signalsTmpPath, signalsPath);
+    if (!signalsSuccess) {
+      console.error(`Warning: Failed to write SIGNALS.json after retries; keeping prior file`);
+    }
+  } catch (e) {
+    console.error(`Warning: Failed to write SIGNALS.json: ${e.message}`);
+  }
+
+  // Always write heartbeat and signal state (these use direct write, no rename)
+  try {
+    fs.writeFileSync(path.join(MON, '.monitor-heartbeat'), String(Math.floor(now / 1000)), 'utf8');
+  } catch (e) {
+    console.error(`Warning: Failed to write heartbeat: ${e.message}`);
+  }
+  try {
+    fs.writeFileSync(path.join(MON, '.signal-state.json'), JSON.stringify({ cycleCount }, null, 2), 'utf8');
+  } catch (e) {
+    console.error(`Warning: Failed to write signal state: ${e.message}`);
+  }
+
+  // Normalize skipped signals to 0 for summary display
+  const junkQuarantinable = junk.skipped ? 0 : (junk.quarantinable || 0);
+  const strayRepoCount = strayRepo.skipped ? 0 : (Array.isArray(strayRepo) ? strayRepo.length : 0);
+  const respawnWatchCount = respawnWatch.skipped ? 0 : (Array.isArray(respawnWatch) ? respawnWatch.length : 0);
+
+  const summaryLine = `stale-loops: ${staleLoops.length}, repos-dirty: ${gitState.filter(g => g.dirty > 0).length}, stale-mem: ${memory.staleCount}, logs-need-rotation: ${needsRotation.length}, junk-quarantinable: ${junkQuarantinable}, stray-repo-scripts: ${strayRepoCount}, alerts-high-med: ${alerts.highMedCount}, respawn-watch: ${respawnWatchCount}, cycle: ${cycleCount}`;
   console.log(summaryLine);
 } catch (e) {
-  console.error('Failed to write signals:', e.message);
+  console.error('Unexpected error during output write:', e.message);
   process.exit(1);
 }