@matt82198/aesop 0.1.0-beta.5 → 0.1.0

package/hooks/pre-push-policy.sh

@@ -3,14 +3,45 @@ set -uo pipefail
 
 json_escape() {
   # Escape backslashes first, then quotes, then control chars for valid JSON
-  # Finding 5: Handle control characters (\n, \r, \t, C0)
+  # Finding 5: Handle ALL C0 control characters (\x00-\x08, \x0b-\x0c, \x0e-\x1f)
   local s="$1"
   s="${s//\\/\\\\}"
   s="${s//\"/\\\"}"
   s="${s//$'\n'/\\n}"
   s="${s//$'\r'/\\r}"
   s="${s//$'\t'/\\t}"
-  printf '%s' "$s"
+  # Escape remaining C0 control characters as \u00XX
+  # Using sed with explicit byte mappings for each C0 char not yet escaped
+  printf '%s' "$s" | sed \
+    -e 's/[\x00]/\\u0000/g' \
+    -e 's/[\x01]/\\u0001/g' \
+    -e 's/[\x02]/\\u0002/g' \
+    -e 's/[\x03]/\\u0003/g' \
+    -e 's/[\x04]/\\u0004/g' \
+    -e 's/[\x05]/\\u0005/g' \
+    -e 's/[\x06]/\\u0006/g' \
+    -e 's/[\x07]/\\u0007/g' \
+    -e 's/[\x08]/\\u0008/g' \
+    -e 's/[\x0b]/\\u000b/g' \
+    -e 's/[\x0c]/\\u000c/g' \
+    -e 's/[\x0e]/\\u000e/g' \
+    -e 's/[\x0f]/\\u000f/g' \
+    -e 's/[\x10]/\\u0010/g' \
+    -e 's/[\x11]/\\u0011/g' \
+    -e 's/[\x12]/\\u0012/g' \
+    -e 's/[\x13]/\\u0013/g' \
+    -e 's/[\x14]/\\u0014/g' \
+    -e 's/[\x15]/\\u0015/g' \
+    -e 's/[\x16]/\\u0016/g' \
+    -e 's/[\x17]/\\u0017/g' \
+    -e 's/[\x18]/\\u0018/g' \
+    -e 's/[\x19]/\\u0019/g' \
+    -e 's/[\x1a]/\\u001a/g' \
+    -e 's/[\x1b]/\\u001b/g' \
+    -e 's/[\x1c]/\\u001c/g' \
+    -e 's/[\x1d]/\\u001d/g' \
+    -e 's/[\x1e]/\\u001e/g' \
+    -e 's/[\x1f]/\\u001f/g'
 }
 compute_sha256() {
   # P1-Bug2 fix: Single helper for sha256sum with fallback to shasum
@@ -250,6 +281,55 @@ check_branch_policy() {
   return 0
 }
 
+get_commit_range() {
+  # Parse pre-push stdin to build commit range(s) for scanning.
+  # Format: <local-ref> <local-sha> <remote-ref> <remote-sha>
+  # A single push (git push --all / multiple branches / multiple tags in one
+  # invocation) can feed MULTIPLE ref tuples on stdin, one per line. Emits
+  # ONE "remote-sha..local-sha" range PER valid tuple found, one per output
+  # line (like check_branch_policy, which already iterates every tuple to
+  # check branch policy) -- P3 wave-25 fix: this used to `return 0` after the
+  # FIRST tuple, so a multi-ref push only ever scanned the first branch's
+  # range and every other ref in the same push silently bypassed the secret
+  # scan. Returns 0 if at least one range was emitted, 1 if none could be
+  # parsed (tty, empty stdin, or no valid tuple) -- single-ref callers see
+  # exactly the same one-line output as before.
+  local local_ref local_sha remote_ref remote_sha
+  local found=0
+
+  if [ -t 0 ]; then
+    # Running interactively on a tty; no stdin to parse
+    return 1
+  fi
+
+  while IFS=' ' read -r local_ref local_sha remote_ref remote_sha || [ -n "$local_ref" ]; do
+    # Skip empty lines
+    if [ -z "$remote_ref" ]; then
+      continue
+    fi
+
+    # Found a valid ref tuple; build its range
+    # If remote_sha is all zeros (new branch), use merge-base with default branch
+    if [ "$remote_sha" = "0000000000000000000000000000000000000000" ]; then
+      # New branch: find merge-base with main/master
+      local default_branch="main"
+      if ! git rev-parse "$default_branch" >/dev/null 2>&1; then
+        default_branch="master"
+      fi
+      printf '%s..%s\n' "$default_branch" "$local_sha"
+    else
+      # Existing branch: use remote sha as base
+      printf '%s..%s\n' "$remote_sha" "$local_sha"
+    fi
+    found=1
+  done
+
+  if [ "$found" -eq 1 ]; then
+    return 0
+  fi
+  return 1
+}
+
 check_secret_scan() {
   local scan_bin
   if command -v python >/dev/null 2>&1; then
@@ -270,17 +350,44 @@ check_secret_scan() {
     return 0
   fi
 
-  # Run scanner and capture output; surface ALLOWED-DOC lines to stderr for visibility
-  local scan_output
-  scan_output=$("$scan_bin" "$scan_script" --staged 2>&1)
-  local exit_code=$?
-
-  # Surface all output including ALLOWED-DOC findings to stderr
-  if [ -n "$scan_output" ]; then
-    printf '%s\n' "$scan_output" >&2
+  # Parse pre-push stdin to get commit range(s), then scan files in each range.
+  # A multi-ref push (git push --all, or multiple branches/tags in one
+  # invocation) yields one range per line from get_commit_range(); scan EVERY
+  # one and fail if ANY range is dirty (P3 wave-25 fix: previously only the
+  # first ref tuple's range was ever scanned).
+  local commit_ranges
+  commit_ranges=$(get_commit_range)
+  local parse_exit_code=$?
+
+  if [ $parse_exit_code -ne 0 ] || [ -z "$commit_ranges" ]; then
+    # Malformed stdin or unable to parse: fail-CLOSED (security P1 fix)
+    # Only fail-open for missing scanner tool, not for malformed input
+    log_block "secret_scan_stdin_parse_failed"
+    printf 'Error: Could not parse pre-push stdin for commit range (malformed or empty)\n' >&2
+    return 1
   fi
 
-  return $exit_code
+  local overall_exit_code=0
+  local range
+  while IFS= read -r range || [ -n "$range" ]; do
+    [ -z "$range" ] && continue
+
+    # Run scanner on this range and capture output
+    local scan_output
+    scan_output=$("$scan_bin" "$scan_script" --range "$range" 2>&1)
+    local scan_exit_code=$?
+
+    # Surface all output including ALLOWED-DOC findings to stderr
+    if [ -n "$scan_output" ]; then
+      printf '%s\n' "$scan_output" >&2
+    fi
+
+    if [ $scan_exit_code -ne 0 ]; then
+      overall_exit_code=$scan_exit_code
+    fi
+  done <<< "$commit_ranges"
+
+  return $overall_exit_code
 }
 
 log_event() {
@@ -707,12 +814,130 @@ run_test_mode() {
     test_failed=$((test_failed + 1))
   fi
 
+  printf '\n=== Test 12: get_commit_range emits ALL ref tuples (multi-ref push) ===\n'
+  (
+    cd "$tmpdir" || exit 1
+    git checkout -q feature/test 2>/dev/null || git checkout -q -b feature/multiref 2>/dev/null
+    local_sha=$(git rev-parse HEAD 2>/dev/null || echo "0000000")
+
+    # Simulate a multi-ref push (git push --all / multiple branches in one
+    # invocation): two ref tuples on stdin. Wave-25 P3 regression: the old
+    # get_commit_range() `return 0`'d after the FIRST tuple, so a multi-ref
+    # push only ever produced ONE range.
+    stdin_input="refs/heads/branch-a $local_sha refs/heads/branch-a 0000000000000000000000000000000000000000
+refs/heads/branch-b $local_sha refs/heads/branch-b 0000000000000000000000000000000000000000"
+
+    ranges=$(printf '%s\n' "$stdin_input" | get_commit_range)
+    range_count=$(printf '%s\n' "$ranges" | grep -c '\.\.')
+
+    if [ "$range_count" -eq 2 ]; then
+      printf 'PASS: get_commit_range emitted %d ranges for a 2-ref push\n' "$range_count"
+    else
+      printf 'FAIL: Expected 2 ranges for a 2-ref push, got %d. Output: %s\n' "$range_count" "$ranges"
+      exit 1
+    fi
+  )
+  if [ $? -eq 0 ]; then
+    test_passed=$((test_passed + 1))
+  else
+    test_failed=$((test_failed + 1))
+  fi
+
+  printf '\n=== Test 13: check_secret_scan scans EVERY ref range, not just the first ===\n'
+  (
+    export AESOP_ROOT="$tmpdir/aesop_multiref"
+    mkdir -p "$AESOP_ROOT/state" "$AESOP_ROOT/tools"
+
+    # Mock scanner: fails only when the --range argument's local-sha side
+    # matches the "dirty" ref's local sha. This proves BOTH ranges from a
+    # multi-ref push are actually scanned -- not just the first -- since the
+    # dirty ref is deliberately placed SECOND in stdin.
+    cat > "$AESOP_ROOT/tools/secret_scan.py" <<'SCANNER'
+#!/usr/bin/env python3
+import sys
+args = sys.argv[1:]
+range_arg = args[args.index("--range") + 1] if "--range" in args else ""
+if "2222222222222222222222222222222222222222" in range_arg:
+    sys.exit(1)
+sys.exit(0)
+SCANNER
+    chmod +x "$AESOP_ROOT/tools/secret_scan.py"
+
+    # First ref tuple is clean, SECOND ref tuple is dirty. Pre-fix,
+    # get_commit_range only ever emitted the first tuple's range, so this
+    # second dirty ref would have silently bypassed the scan entirely.
+    stdin_input="refs/heads/clean-branch 1111111111111111111111111111111111111111 refs/heads/clean-branch 0000000000000000000000000000000000000000
+refs/heads/dirty-branch 2222222222222222222222222222222222222222 refs/heads/dirty-branch 0000000000000000000000000000000000000000"
+
+    if printf '%s\n' "$stdin_input" | check_secret_scan >/dev/null 2>&1; then
+      printf 'FAIL: check_secret_scan should have blocked on the second (dirty) ref range\n'
+      exit 1
+    fi
+    printf 'PASS: check_secret_scan blocked on a dirty range from a NON-first ref tuple\n'
+  )
+  if [ $? -eq 0 ]; then
+    test_passed=$((test_passed + 1))
+  else
+    test_failed=$((test_failed + 1))
+  fi
+
+  printf '\n=== Test 14: main() stdin capture-once does not starve the second consumer ===\n'
+  (
+    export AESOP_ROOT="$tmpdir/aesop_stdin_double_read"
+    mkdir -p "$AESOP_ROOT/state" "$AESOP_ROOT/tools"
+    cat > "$AESOP_ROOT/tools/secret_scan.py" <<'SCANNER'
+#!/usr/bin/env python3
+import sys
+sys.exit(0)
+SCANNER
+    chmod +x "$AESOP_ROOT/tools/secret_scan.py"
+
+    cd "$tmpdir" || exit 1
+    git checkout -q feature/test 2>/dev/null || git checkout -q -b feature/stdin_double 2>/dev/null
+    local_sha=$(git rev-parse HEAD 2>/dev/null || echo "0000000")
+
+    stdin_input="refs/heads/feature/test $local_sha refs/heads/feature/test 0000000000000000000000000000000000000000"
+
+    # Replicate exactly what main() now does: capture stdin ONCE, then feed
+    # each consumer its own here-string copy. Before this fix, main() called
+    # check_branch_policy (reading fd0 directly) then check_secret_scan
+    # (also reading fd0 directly) against the SAME real pipe -- the first
+    # call drained it, so get_commit_range inside the second call always
+    # saw EOF and fail-closed, blocking EVERY push regardless of content.
+    captured=$(printf '%s\n' "$stdin_input" | cat)
+
+    if ! check_branch_policy <<< "$captured" >/dev/null 2>&1; then
+      printf 'FAIL: check_branch_policy unexpectedly blocked the feature branch\n'
+      exit 1
+    fi
+
+    stderr_output=$( { check_secret_scan <<< "$captured"; } 2>&1 1>/dev/null )
+    scan_exit=$?
+
+    if [ $scan_exit -ne 0 ]; then
+      printf 'FAIL: check_secret_scan failed after check_branch_policy already read the SAME captured stdin (stdin-starvation regression). stderr: %s\n' "$stderr_output"
+      exit 1
+    fi
+
+    if printf '%s' "$stderr_output" | grep -q 'parse_failed\|malformed'; then
+      printf 'FAIL: check_secret_scan reported malformed/empty stdin -- it never saw the ref tuple\n'
+      exit 1
+    fi
+
+    printf 'PASS: check_secret_scan still sees the ref tuple after check_branch_policy read the same captured stdin\n'
+  )
+  if [ $? -eq 0 ]; then
+    test_passed=$((test_passed + 1))
+  else
+    test_failed=$((test_failed + 1))
+  fi
+
   printf '\n=== Test Results ===\n'
   printf 'PASSED: %d\n' "$test_passed"
   printf 'FAILED: %d\n' "$test_failed"
 
   if [ "$test_failed" -eq 0 ]; then
-    printf '\nAll 11 tests passed.\n'
+    printf '\nAll 14 tests passed.\n'
     return 0
   else
     printf '\nSome tests failed.\n'
@@ -732,14 +957,27 @@ main() {
     exit $?
   fi
 
-  # git pre-push provides ref info on stdin, pass it to check_branch_policy
-  if ! check_branch_policy; then
+  # git pre-push provides ref info on stdin, and BOTH check_branch_policy and
+  # check_secret_scan (via get_commit_range) need to read every ref tuple.
+  # Capture the real pipe ONCE here and hand each consumer its own here-string
+  # copy -- reading a pipe twice on the same fd starves the second reader
+  # (once check_branch_policy drains it, get_commit_range would see nothing
+  # but EOF and fail-closed on every push). A here-string preserves each
+  # function's existing tty-vs-pipe read semantics unchanged (an interactive
+  # tty yields no captured content, which both functions already treat the
+  # same way as "no ref tuples" via their existing fallback/fail-closed paths).
+  local prepush_stdin=""
+  if [ ! -t 0 ]; then
+    prepush_stdin=$(cat)
+  fi
+
+  if ! check_branch_policy <<< "$prepush_stdin"; then
     printf 'Error: Push to main/master is blocked by policy\n' >&2
     log_block "push_to_protected_branch"
     exit 1
   fi
 
-  if ! check_secret_scan; then
+  if ! check_secret_scan <<< "$prepush_stdin"; then
     printf 'Error: Secret scan failed. Push blocked.\n' >&2
     log_block "secret_scan_failure"
     exit 1

package/monitor/CLAUDE.md

@@ -4,18 +4,18 @@
 
 ## Files
 
-- **CHARTER.md** — Governance document; defines 10 signal checks (4 of them extended/opt-in), action tiers (AUTO/PROPOSE), outputs, single-instance guard, single-writer discipline. Read-only; behavior changes only via PROPOSALS/behavioral-PR flow.
+- **CHARTER.md** — Governance document; defines 11 signal checks (4 of them extended/opt-in), action tiers (AUTO/PROPOSE), outputs, single-instance guard, single-writer discipline. Read-only; behavior changes only via PROPOSALS/behavioral-PR flow.
 - **collect-signals.mjs** — Deterministic signal collector (Node.js built-ins only); emits BRIEF.md + SIGNALS.json each cycle; reads config from env or aesop.config.json.
 - **BRIEF.md** — Human-readable cycle snapshot (heartbeats, git state, memory freshness, log rotation, junk sprawl, stray scripts, security alerts, respawn watch, cost cadence, unreviewed prompts); overwritten each cycle; runtime.
 - **SIGNALS.json** — Machine-readable metrics (same signal keys as BRIEF); JSON; overwritten each cycle; runtime.
-- **PROPOSALS.md** — Structured inbox for user approval (idempotent per signal key, append-only); never edited by monitor after emission; tracks respawn-watch-breach, stray-repo-scripts, security-alerts-high-med, stale-memory-files; gitignored.
+- **PROPOSALS.md** — Structured inbox for user approval (idempotent per signal key, append-only); never edited by monitor after emission; tracks isolation-violation-detected, respawn-watch-breach, stray-repo-scripts, security-alerts-high-med, stale-memory-files; gitignored.
 - **ACTIONS.log** — Append-only log of AUTO tier actions taken (heartbeat updates, log rotation invokes, junk quarantine); runtime; gitignored.
 - **.monitor-heartbeat** — Epoch timestamp (line 1) for single-instance liveness check (<300s = skip cycle); runtime; gitignored.
 - **.signal-state.json** — Sidecar state (cycleCount, etc.); runtime; gitignored.
 
 ## Contracts
 
-**Signal keys collected**: heartbeats, git, memory, logs, junk, strayRepo, alerts, respawnWatch, costTick, unreviewedPrompts. Outputs: BRIEF.md (human), SIGNALS.json (machine); both runtime/gitignored. PROPOSALS.md (tracked, append-only); ACTIONS.log (runtime/gitignored).
+**Signal keys collected**: heartbeats, git, memory, logs, junk, strayRepo, alerts, respawnWatch, costTick, unreviewedPrompts, isolationViolations. Outputs: BRIEF.md (human), SIGNALS.json (machine); both runtime/gitignored. PROPOSALS.md (tracked, append-only); ACTIONS.log (runtime/gitignored).
 
 **Extended signals (opt-in, default OFF)**: checks 5 (junk), 6 (strayRepo), 8 (respawnWatch), and 10 (unreviewedPrompts) are extended — disabled by default.
 - Config key: `monitor.extended_signals` (boolean, default `false`) in aesop.config.json.

package/monitor/collect-signals.mjs

@@ -33,8 +33,8 @@ function expandPath(pathStr) {
   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) => {
+  // Expand environment variables like $VAR, $VAR_1, or ${myVar}
+  return pathStr.replace(/\$\{?([A-Za-z_][A-Za-z0-9_]*)\}?/g, (match, varName) => {
     return process.env[varName] || match;
   });
 }
@@ -67,6 +67,12 @@ const STATE_DIR = expandPath(
   path.join(AESOP_ROOT, 'state')
 );
 
+const FLEET_LEDGER = expandPath(
+  process.env.AESOP_FLEET_LEDGER ||
+  config.fleet_ledger ||
+  path.join(BRAIN_ROOT, 'FLEET-LEDGER.md')
+);
+
 const MON = path.join(AESOP_ROOT, 'monitor');
 
 // Config-driven thresholds and feature flags
@@ -259,7 +265,8 @@ function checkMemoryFreshness() {
 }
 
 // 4) Log file status check
-function checkLogFiles() {
+// Optional: accepts pre-read content for SECURITY-ALERTS.log to avoid redundant read
+function checkLogFiles(securityAlertsContent = null) {
   const logFiles = [
     path.join(STATE_DIR, 'FLEET-BACKUP.log'),
     path.join(STATE_DIR, 'SECURITY-ALERTS.log'),
@@ -273,7 +280,11 @@ function checkLogFiles() {
     if (st) {
       sizeKb = (st.size / 1024).toFixed(1);
       try {
-        const content = fs.readFileSync(logPath, 'utf8');
+        // Use pre-read content for SECURITY-ALERTS.log if provided
+        const isSecurityAlerts = logPath === path.join(STATE_DIR, 'SECURITY-ALERTS.log');
+        const content = isSecurityAlerts && securityAlertsContent !== null
+          ? securityAlertsContent
+          : fs.readFileSync(logPath, 'utf8');
         lineCount = content.split('\n').filter(l => l.trim()).length;
       } catch {
         // skip
@@ -345,8 +356,10 @@ function detectStrayRepoScripts() {
       .map(s => s.trim())
       .filter(Boolean);
     for (const f of new Set(recent)) {
-      if (/^[^/\\]+\.(py|mjs|js|sql)$/.test(f)) {
-        strayRepo.push(`${path.basename(repoPath)}: ${f}`);
+      // Normalize git-output paths to forward slashes immediately after read
+      const normalized = f.replace(/\\/g, '/');
+      if (/^[^/]+\.(py|mjs|js|sql)$/.test(normalized)) {
+        strayRepo.push(`${path.basename(repoPath)}: ${normalized}`);
       }
     }
   }
@@ -354,12 +367,14 @@ function detectStrayRepoScripts() {
 }
 
 // 7) Security alert review
-function checkSecurityAlerts() {
+// Optional: accepts pre-read content to avoid redundant file read
+function checkSecurityAlerts(securityAlertsContent = null) {
   const alertLog = path.join(STATE_DIR, 'SECURITY-ALERTS.log');
   const st = stat(alertLog);
   if (!st) return { count: 0, highMedCount: 0 };
   try {
-    const content = fs.readFileSync(alertLog, 'utf8');
+    // Use pre-read content if provided, otherwise read file
+    const content = securityAlertsContent !== null ? securityAlertsContent : fs.readFileSync(alertLog, 'utf8');
     const lines = content.split('\n');
     const highMedCount = lines.filter(l => /HIGH|MED/.test(l) && !l.includes('SUPPRESSED-FP')).length;
     return { count: lines.filter(l => l.trim()).length, highMedCount };
@@ -368,20 +383,89 @@ function checkSecurityAlerts() {
   }
 }
 
-// 8) Respawn watch (Rule 6 retry cap)
+// === Cursor tracking utilities (for ledger incremental read) ===
+// Helper: Load cursor state (byte offset + line hash of last processed line)
+function loadCursor() {
+  const cursorPath = path.join(MON, '.ledger-cursor.json');
+  try {
+    if (fs.existsSync(cursorPath)) {
+      return JSON.parse(fs.readFileSync(cursorPath, 'utf8'));
+    }
+  } catch {
+    // Parse error; treat as missing cursor
+  }
+  return { byteOffset: 0, lineHash: '' };
+}
+
+// Helper: Save cursor state (byte offset + line hash)
+function saveCursor(byteOffset, lineHash) {
+  const cursorPath = path.join(MON, '.ledger-cursor.json');
+  try {
+    fs.mkdirSync(MON, { recursive: true });
+    fs.writeFileSync(cursorPath, JSON.stringify({ byteOffset, lineHash }, null, 2), 'utf8');
+  } catch (e) {
+    // Fail-open: log warning but don't crash
+    console.error(`Warning: Failed to save ledger cursor: ${e.message}`);
+  }
+}
+
+// Helper: Compute a simple hash of a string (for integrity check)
+function simpleHash(str) {
+  let h = 0;
+  for (let i = 0; i < str.length; i++) {
+    h = ((h << 5) - h) + str.charCodeAt(i);
+    h |= 0; // Convert to 32-bit integer
+  }
+  return Math.abs(h).toString(16);
+}
+
+// 8) Respawn watch (Rule 6 retry cap) — incremental read with cursor
 function detectRespawnWatch() {
   const respawnWatch = [];
-  const ledgerPath = path.join(BRAIN_ROOT, 'FLEET-LEDGER.md');
-  if (!fs.existsSync(ledgerPath)) return respawnWatch;
+  if (!fs.existsSync(FLEET_LEDGER)) return respawnWatch;
+
   try {
-    const content = fs.readFileSync(ledgerPath, 'utf8');
-    const lines = content.split('\n').filter(l => l.trim() && !l.startsWith('|'));
+    const buffer = fs.readFileSync(FLEET_LEDGER);
+    const content = buffer.toString('utf8');
+
+    // Load cursor to find starting point
+    const cursor = loadCursor();
+    let startOffset = cursor.byteOffset;
+
+    // If cursor points beyond file, reset to start (file was truncated or rotated)
+    if (startOffset > buffer.length) {
+      startOffset = 0;
+    }
+
+    // Extract only new content since last cursor position
+    const newContent = content.substring(startOffset);
+
+    // Split new content into lines, filtering empty and header lines
+    // Keep data rows (start with | and contain data), skip header rows (| --- | or column names)
+    const newLines = newContent.split('\n')
+      .filter(l => {
+        const trimmed = l.trim();
+        if (!trimmed) return false; // Skip empty lines
+        // Skip header separator rows (contain --- between pipes)
+        if (/\|\s*---/.test(trimmed)) return false;
+        // Skip column name row (has 'timestamp' or 'agent' or 'dispatch' or 'description')
+        if (trimmed.includes('timestamp') && trimmed.includes('agent')) return false;
+        // Keep all other rows starting with |
+        return trimmed.startsWith('|');
+      });
+
+    // If no new lines, return early (nothing to process)
+    if (newLines.length === 0) {
+      return respawnWatch;
+    }
+
+    // Process new lines to detect respawn violations
     const windowSize = 50;
-    const recentStart = Math.max(0, lines.length - windowSize);
+    const recentLines = newLines.slice(Math.max(0, newLines.length - windowSize));
     const signatures = {};
     const normalize = (desc) => (desc || '').substring(0, 40).toLowerCase().trim();
-    for (let i = recentStart; i < lines.length; i++) {
-      const line = lines[i];
+
+    for (const line of recentLines) {
       const parts = line.split('|').map(s => s.trim());
       if (parts.length >= 4) {
         const description = parts[3];
@@ -389,6 +473,8 @@ function detectRespawnWatch() {
         if (sig) signatures[sig] = (signatures[sig] || 0) + 1;
       }
     }
+
+    // Check for violations (count > 3)
     for (const [sig, count] of Object.entries(signatures)) {
       if (count > 3) {
         respawnWatch.push({
@@ -398,9 +484,17 @@ function detectRespawnWatch() {
         });
       }
     }
-  } catch {
-    // fail-open on error
+
+    // Update cursor to end of file
+    const lastLine = newLines[newLines.length - 1] || '';
+    const newByteOffset = buffer.length;
+    const newLineHash = simpleHash(lastLine);
+    saveCursor(newByteOffset, newLineHash);
+  } catch (e) {
+    // Fail-open on error
+    console.error(`Warning: Failed to read FLEET-LEDGER: ${e.message}`);
   }
+
   return respawnWatch;
 }
 
@@ -673,6 +767,14 @@ function emitProposal(signalKey, problem, suggestedChange) {
 
   // If lock acquisition failed (fail-closed), skip emission for this cycle
   if (!lockDir) {
+    // On lock timeout, append a one-line MISSED-PROPOSAL record to ACTIONS.log (append-only)
+    // so the condition surfaces next cycle
+    const actionsLogPath = path.join(MON, 'ACTIONS.log');
+    try {
+      fs.appendFileSync(actionsLogPath, `[${timestamp}] MISSED-PROPOSAL: ${signalKey} (lock timeout)\n`, 'utf8');
+    } catch (e) {
+      // Fail-open: ignore write errors to ACTIONS.log
+    }
     return;
   }
 
@@ -721,17 +823,28 @@ ${suggestedChange}
 }
 
 // === Main ===
+// Read SECURITY-ALERTS.log once and share the content with both consumers to avoid redundant file read
+let securityAlertsContent = null;
+const securityAlertsPath = path.join(STATE_DIR, 'SECURITY-ALERTS.log');
+try {
+  if (fs.existsSync(securityAlertsPath)) {
+    securityAlertsContent = fs.readFileSync(securityAlertsPath, 'utf8');
+  }
+} catch {
+  // File exists but is unreadable; consumers will handle gracefully
+}
+
 const staleLoops = checkHeartbeats();
 const gitState = checkGitState();
 const memory = checkMemoryFreshness();
-const logFiles = checkLogFiles();
+const logFiles = checkLogFiles(securityAlertsContent);
 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 alerts = checkSecurityAlerts(securityAlertsContent);
 
 const respawnWatch = extendedSignals ? detectRespawnWatch() : { skipped: true };
 const { cycleCount, costTick } = trackCostCadence();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@matt82198/aesop",
-  "version": "0.1.0-beta.5",
+  "version": "0.1.0",
   "description": "Multi-agent orchestration for AI coding agents, designed to survive failure \u00e2\u20ac\u201d a plain-file brain, git as the only durable layer, cheap subagent fleets, and guardrails enforced in code.",
   "bin": {
     "aesop": "bin/cli.js"
@@ -12,12 +12,20 @@
     "dash/",
     "monitor/",
     "mcp/",
-    "tools/",
-    "ui/",
+    "tools/*.py",
+    "tools/*.sh",
+    "tools/*.mjs",
+    "tools/*.js",
+    "tools/*.md",
+    "ui/*.py",
+    "ui/api/*.py",
+    "ui/*.md",
+    "ui/web/dist/",
     "docs/",
     "hooks/",
     "skills/",
-    "state_store/",
+    "state_store/*.py",
+    "state_store/*.md",
     "scan/",
     "aesop.config.example.json",
     "CLAUDE-TEMPLATE.md",
@@ -38,7 +46,7 @@
     "resilience",
     "template"
   ],
-  "license": "MIT",
+  "license": "SEE LICENSE IN LICENSE",
   "author": "Matt Culliton",
   "repository": {
     "type": "git",
@@ -52,8 +60,8 @@
     "access": "public"
   },
   "scripts": {
-    "test": "node --test --test-force-exit --test-timeout=60000 tests/**/*.test.mjs",
-    "test:node": "node --test --test-force-exit --test-timeout=60000 tests/**/*.test.mjs",
+    "test": "node --test --test-force-exit --test-timeout=60000 tests/*.test.mjs",
+    "test:node": "node --test --test-force-exit --test-timeout=60000 tests/*.test.mjs",
     "test:sh": "bash tests/test_pre_push_policy.sh && bash tests/test-run-watchdog.sh && bash tests/backup-fleet.test.sh && bash tests/test_reconstitute.sh && bash tests/test_reconstitute_fixes.sh && bash tests/test_agent_forensics.sh && bash hooks/pre-push-policy.sh --test && bash tools/reconstitute.sh --test",
     "test:py": "python -m unittest discover -s tests",
     "test:all": "npm run test:node && npm run test:sh && npm run test:py"

package/scan/CLAUDE.md

@@ -0,0 +1,30 @@
+# scan/ — Example IOC/secret scanner template
+
+The `fleet-scan.example.mjs` is a config-driven template for scanning committed code and fleet transcripts for security and alignment red-flags during each watchdog cycle.
+
+## Setup
+
+1. Copy `fleet-scan.example.mjs` → `fleet-scan.mjs` (in the same directory)
+2. Edit the configuration section to match your fleet setup (REPOS array, PROJECT_ROOTS paths)
+3. Configure paths via `aesop.config.json` or environment variables:
+   - `AESOP_FLEET_ROOT`: root directory containing your project repositories
+   - `AESOP_TRANSCRIPTS_ROOT`: root directory containing `~/.claude/projects` transcripts
+4. Ensure `aesop.config.json` contains repo definitions (see `aesop.config.example.json`)
+
+## How it works
+
+When enabled (by copying to `fleet-scan.mjs`), the scanner:
+- Runs every watchdog cycle (default: every 150s)
+- Scans git repositories and transcript directories for patterns matching your configured IOC/secret rules
+- Logs findings to `SECURITY-ALERTS.log` with severity (HIGH/MED/LOW)
+- Never blocks the fleet (non-fatal, append-only)
+- Marks reviewed findings with `NOTE:` or `RESOLVED-FP` prefix to skip future alerts
+
+## Customization
+
+Edit the `fleet-scan.mjs` rules section to add domain-specific checks:
+- Pattern-based secret/credential detection
+- Alignment violations (e.g., non-approved libraries, unclosed TODO markers)
+- Transcript red-flags (e.g., cost anomalies, stalled agents)
+
+Output findings via the `add(severity, kind, where, detail)` function; the scanner handles deduplication and logging.