perf: tail-scan discord stop hook + single-scan supervisor reconcile

[Castrozan]

What

Focused performance pass on the clawde agent loop. A 35-agent adversarial workflow profiled every subsystem (heartbeat gate/probe, supervisor reconcile, wrapper/watchdog, discord hooks, a2a adapter, identity/redeploy) and confirmed 11 real hot-path bottlenecks against source. The two that are both high-impact and live are fixed and measured here; the rest are dormant or LOW with fixes the verifiers rated unsafe, documented with reasons in PERF_TRACKER.md.

Fixes

Discord Stop hook: tail-scan instead of full transcript parse (every turn-end).
The hook json.loads-ed the entire transcript jsonl on every turn-end; with the 1M context window live transcripts reach tens of MB, so each turn paid an O(transcript) parse. It only needs the suffix from the newest discord-envelope user turn onward, so it now reverse-reads the file newest-line-first and stops at that turn. Decision semantics are identical.

Benchmark (47 MB / 8000-entry transcript, best of 5): common case 217.8ms → 0.8ms (272x); discord turn 50 entries deep 217.2ms → 36.0ms.

Supervisor reconcile: one ps scan instead of pgrep + N×ps (every 10s).
find_session_agent_wrapper_processes ran a global pgrep then forked one ps -ww -p PID per matched wrapper. It now reads every command line once with ps -axww -o pid=,command= and filters in Python, so discovery is a single fork regardless of wrapper count. Live (2 sessions × 4 wrappers): discovery forks drop ~10 → 2 per cycle, roughly 48k fewer forks/day. Matching is identical to the old pgrep -f pattern.

How verified

• nix flake check green (unit-tests, formatting, lint).
• Full suite 235 tests pass; 7 new tests (5 tail-reader edge cases incl. reverse-read with missing trailing newline and older-turn precedence; 2 single-scan discovery assertions, one asserting a constant subprocess-fork count).
• Before/after microbenchmarks on synthetic large transcripts and subprocess-count assertions, recorded in the commits and PERF_TRACKER.md.
• Behavior-preserving: the workflow independently confirmed the hook fix over 800 fuzz trials with zero decision mismatches vs the old full parse.

Not merged

Base main, for review only.

[Castrozan]

What

Focused performance pass on the clawde agent loop. A 35-agent adversarial workflow profiled every subsystem (heartbeat gate/probe, supervisor reconcile, wrapper/watchdog, discord hooks, a2a adapter, identity/redeploy) and confirmed 11 real hot-path bottlenecks against source. The two that are both high-impact and live are fixed and measured here; the rest are dormant or LOW with fixes the verifiers rated unsafe, documented with reasons in PERF_TRACKER.md.

Fixes

Discord Stop hook: tail-scan instead of full transcript parse (every turn-end).
The hook json.loads-ed the entire transcript jsonl on every turn-end; with the 1M context window live transcripts reach tens of MB, so each turn paid an O(transcript) parse. It only needs the suffix from the newest discord-envelope user turn onward, so it now reverse-reads the file newest-line-first and stops at that turn. Decision semantics are identical.

Benchmark (47 MB / 8000-entry transcript, best of 5): common case 217.8ms → 0.8ms (272x); discord turn 50 entries deep 217.2ms → 36.0ms.

Supervisor reconcile: one ps scan instead of pgrep + N×ps (every 10s).
find_session_agent_wrapper_processes ran a global pgrep then forked one ps -ww -p PID per matched wrapper. It now reads every command line once with ps -axww -o pid=,command= and filters in Python, so discovery is a single fork regardless of wrapper count. Live (2 sessions × 4 wrappers): discovery forks drop ~10 → 2 per cycle, roughly 48k fewer forks/day. Matching is identical to the old pgrep -f pattern.

How verified

• nix flake check green (unit-tests, formatting, lint).
• Full suite 235 tests pass; 7 new tests (5 tail-reader edge cases incl. reverse-read with missing trailing newline and older-turn precedence; 2 single-scan discovery assertions, one asserting a constant subprocess-fork count).
• Before/after microbenchmarks on synthetic large transcripts and subprocess-count assertions, recorded in the commits and PERF_TRACKER.md.
• Behavior-preserving: the workflow independently confirmed the hook fix over 800 fuzz trials with zero decision mismatches vs the old full parse.

Not merged

Base main, for review only.

[Castrozan]

What

Focused performance pass on the clawde agent loop. A 35-agent adversarial workflow profiled every subsystem (heartbeat gate/probe, supervisor reconcile, wrapper/watchdog, discord hooks, a2a adapter, identity/redeploy) and confirmed 11 real hot-path bottlenecks against source. The two that are both high-impact and live are fixed and measured here; the rest are dormant or LOW with fixes the verifiers rated unsafe, documented with reasons in PERF_TRACKER.md.

Fixes

Discord Stop hook: tail-scan instead of full transcript parse (every turn-end).
The hook json.loads-ed the entire transcript jsonl on every turn-end; with the 1M context window live transcripts reach tens of MB, so each turn paid an O(transcript) parse. It only needs the suffix from the newest discord-envelope user turn onward, so it now reverse-reads the file newest-line-first and stops at that turn. Decision semantics are identical.

Benchmark (47 MB / 8000-entry transcript, best of 5): common case 217.8ms → 0.8ms (272x); discord turn 50 entries deep 217.2ms → 36.0ms.

Supervisor reconcile: one ps scan instead of pgrep + N×ps (every 10s).
find_session_agent_wrapper_processes ran a global pgrep then forked one ps -ww -p PID per matched wrapper. It now reads every command line once with ps -axww -o pid=,command= and filters in Python, so discovery is a single fork regardless of wrapper count. Live (2 sessions × 4 wrappers): discovery forks drop ~10 → 2 per cycle, roughly 48k fewer forks/day. Matching is identical to the old pgrep -f pattern.

How verified

• nix flake check green (unit-tests, formatting, lint).
• Full suite 235 tests pass; 7 new tests (5 tail-reader edge cases incl. reverse-read with missing trailing newline and older-turn precedence; 2 single-scan discovery assertions, one asserting a constant subprocess-fork count).
• Before/after microbenchmarks on synthetic large transcripts and subprocess-count assertions, recorded in the commits and PERF_TRACKER.md.
• Behavior-preserving: the workflow independently confirmed the hook fix over 800 fuzz trials with zero decision mismatches vs the old full parse.

Not merged

Base main, for review only.

[Castrozan]

What

Focused performance pass on the clawde agent loop. A 35-agent adversarial workflow profiled every subsystem (heartbeat gate/probe, supervisor reconcile, wrapper/watchdog, discord hooks, a2a adapter, identity/redeploy) and confirmed 11 real hot-path bottlenecks against source. The two that are both high-impact and live are fixed and measured here; the rest are dormant or LOW with fixes the verifiers rated unsafe, documented with reasons in PERF_TRACKER.md.

Fixes

Discord Stop hook: tail-scan instead of full transcript parse (every turn-end).
The hook json.loads-ed the entire transcript jsonl on every turn-end; with the 1M context window live transcripts reach tens of MB, so each turn paid an O(transcript) parse. It only needs the suffix from the newest discord-envelope user turn onward, so it now reverse-reads the file newest-line-first and stops at that turn. Decision semantics are identical.

Benchmark (47 MB / 8000-entry transcript, best of 5): common case 217.8ms → 0.8ms (272x); discord turn 50 entries deep 217.2ms → 36.0ms.

Supervisor reconcile: one ps scan instead of pgrep + N×ps (every 10s).
find_session_agent_wrapper_processes ran a global pgrep then forked one ps -ww -p PID per matched wrapper. It now reads every command line once with ps -axww -o pid=,command= and filters in Python, so discovery is a single fork regardless of wrapper count. Live (2 sessions × 4 wrappers): discovery forks drop ~10 → 2 per cycle, roughly 48k fewer forks/day. Matching is identical to the old pgrep -f pattern.

How verified

• nix flake check green (unit-tests, formatting, lint).
• Full suite 235 tests pass; 7 new tests (5 tail-reader edge cases incl. reverse-read with missing trailing newline and older-turn precedence; 2 single-scan discovery assertions, one asserting a constant subprocess-fork count).
• Before/after microbenchmarks on synthetic large transcripts and subprocess-count assertions, recorded in the commits and PERF_TRACKER.md.
• Behavior-preserving: the workflow independently confirmed the hook fix over 800 fuzz trials with zero decision mismatches vs the old full parse.

Not merged

Base main, for review only.

[Castrozan]

What

Focused performance pass on the clawde agent loop. A 35-agent adversarial workflow profiled every subsystem (heartbeat gate/probe, supervisor reconcile, wrapper/watchdog, discord hooks, a2a adapter, identity/redeploy) and confirmed 11 real hot-path bottlenecks against source. The two that are both high-impact and live are fixed and measured here; the rest are dormant or LOW with fixes the verifiers rated unsafe, documented with reasons in PERF_TRACKER.md.

Fixes

Discord Stop hook: tail-scan instead of full transcript parse (every turn-end).
The hook json.loads-ed the entire transcript jsonl on every turn-end; with the 1M context window live transcripts reach tens of MB, so each turn paid an O(transcript) parse. It only needs the suffix from the newest discord-envelope user turn onward, so it now reverse-reads the file newest-line-first and stops at that turn. Decision semantics are identical.

Benchmark (47 MB / 8000-entry transcript, best of 5): common case 217.8ms → 0.8ms (272x); discord turn 50 entries deep 217.2ms → 36.0ms.

Supervisor reconcile: one ps scan instead of pgrep + N×ps (every 10s).
find_session_agent_wrapper_processes ran a global pgrep then forked one ps -ww -p PID per matched wrapper. It now reads every command line once with ps -axww -o pid=,command= and filters in Python, so discovery is a single fork regardless of wrapper count. Live (2 sessions × 4 wrappers): discovery forks drop ~10 → 2 per cycle, roughly 48k fewer forks/day. Matching is identical to the old pgrep -f pattern.

How verified

• nix flake check green (unit-tests, formatting, lint).
• Full suite 235 tests pass; 7 new tests (5 tail-reader edge cases incl. reverse-read with missing trailing newline and older-turn precedence; 2 single-scan discovery assertions, one asserting a constant subprocess-fork count).
• Before/after microbenchmarks on synthetic large transcripts and subprocess-count assertions, recorded in the commits and PERF_TRACKER.md.
• Behavior-preserving: the workflow independently confirmed the hook fix over 800 fuzz trials with zero decision mismatches vs the old full parse.

Not merged

Base main, for review only.

[Castrozan]

What

Focused performance pass on the clawde agent loop. A 35-agent adversarial workflow profiled every subsystem (heartbeat gate/probe, supervisor reconcile, wrapper/watchdog, discord hooks, a2a adapter, identity/redeploy) and confirmed 11 real hot-path bottlenecks against source. The two that are both high-impact and live are fixed and measured here; the rest are dormant or LOW with fixes the verifiers rated unsafe, documented with reasons in PERF_TRACKER.md.

Fixes

Discord Stop hook: tail-scan instead of full transcript parse (every turn-end).
The hook json.loads-ed the entire transcript jsonl on every turn-end; with the 1M context window live transcripts reach tens of MB, so each turn paid an O(transcript) parse. It only needs the suffix from the newest discord-envelope user turn onward, so it now reverse-reads the file newest-line-first and stops at that turn. Decision semantics are identical.

Benchmark (47 MB / 8000-entry transcript, best of 5): common case 217.8ms → 0.8ms (272x); discord turn 50 entries deep 217.2ms → 36.0ms.

Supervisor reconcile: one ps scan instead of pgrep + N×ps (every 10s).
find_session_agent_wrapper_processes ran a global pgrep then forked one ps -ww -p PID per matched wrapper. It now reads every command line once with ps -axww -o pid=,command= and filters in Python, so discovery is a single fork regardless of wrapper count. Live (2 sessions × 4 wrappers): discovery forks drop ~10 → 2 per cycle, roughly 48k fewer forks/day. Matching is identical to the old pgrep -f pattern.

How verified

• nix flake check green (unit-tests, formatting, lint).
• Full suite 235 tests pass; 7 new tests (5 tail-reader edge cases incl. reverse-read with missing trailing newline and older-turn precedence; 2 single-scan discovery assertions, one asserting a constant subprocess-fork count).
• Before/after microbenchmarks on synthetic large transcripts and subprocess-count assertions, recorded in the commits and PERF_TRACKER.md.
• Behavior-preserving: the workflow independently confirmed the hook fix over 800 fuzz trials with zero decision mismatches vs the old full parse.

Not merged

Base main, for review only.

[Castrozan]

What

Focused performance pass on the clawde agent loop. A 35-agent adversarial workflow profiled every subsystem (heartbeat gate/probe, supervisor reconcile, wrapper/watchdog, discord hooks, a2a adapter, identity/redeploy) and confirmed 11 real hot-path bottlenecks against source. The two that are both high-impact and live are fixed and measured here; the rest are dormant or LOW with fixes the verifiers rated unsafe, documented with reasons in PERF_TRACKER.md.

Fixes

Discord Stop hook: tail-scan instead of full transcript parse (every turn-end).
The hook json.loads-ed the entire transcript jsonl on every turn-end; with the 1M context window live transcripts reach tens of MB, so each turn paid an O(transcript) parse. It only needs the suffix from the newest discord-envelope user turn onward, so it now reverse-reads the file newest-line-first and stops at that turn. Decision semantics are identical.

Benchmark (47 MB / 8000-entry transcript, best of 5): common case 217.8ms → 0.8ms (272x); discord turn 50 entries deep 217.2ms → 36.0ms.

Supervisor reconcile: one ps scan instead of pgrep + N×ps (every 10s).
find_session_agent_wrapper_processes ran a global pgrep then forked one ps -ww -p PID per matched wrapper. It now reads every command line once with ps -axww -o pid=,command= and filters in Python, so discovery is a single fork regardless of wrapper count. Live (2 sessions × 4 wrappers): discovery forks drop ~10 → 2 per cycle, roughly 48k fewer forks/day. Matching is identical to the old pgrep -f pattern.

How verified

• nix flake check green (unit-tests, formatting, lint).
• Full suite 235 tests pass; 7 new tests (5 tail-reader edge cases incl. reverse-read with missing trailing newline and older-turn precedence; 2 single-scan discovery assertions, one asserting a constant subprocess-fork count).
• Before/after microbenchmarks on synthetic large transcripts and subprocess-count assertions, recorded in the commits and PERF_TRACKER.md.
• Behavior-preserving: the workflow independently confirmed the hook fix over 800 fuzz trials with zero decision mismatches vs the old full parse.

Not merged

Base main, for review only.

[Castrozan]

What

Focused performance pass on the clawde agent loop. A 35-agent adversarial workflow profiled every subsystem (heartbeat gate/probe, supervisor reconcile, wrapper/watchdog, discord hooks, a2a adapter, identity/redeploy) and confirmed 11 real hot-path bottlenecks against source. The two that are both high-impact and live are fixed and measured here; the rest are dormant or LOW with fixes the verifiers rated unsafe, documented with reasons in PERF_TRACKER.md.

Fixes

Discord Stop hook: tail-scan instead of full transcript parse (every turn-end).
The hook json.loads-ed the entire transcript jsonl on every turn-end; with the 1M context window live transcripts reach tens of MB, so each turn paid an O(transcript) parse. It only needs the suffix from the newest discord-envelope user turn onward, so it now reverse-reads the file newest-line-first and stops at that turn. Decision semantics are identical.

Benchmark (47 MB / 8000-entry transcript, best of 5): common case 217.8ms → 0.8ms (272x); discord turn 50 entries deep 217.2ms → 36.0ms.

Supervisor reconcile: one ps scan instead of pgrep + N×ps (every 10s).
find_session_agent_wrapper_processes ran a global pgrep then forked one ps -ww -p PID per matched wrapper. It now reads every command line once with ps -axww -o pid=,command= and filters in Python, so discovery is a single fork regardless of wrapper count. Live (2 sessions × 4 wrappers): discovery forks drop ~10 → 2 per cycle, roughly 48k fewer forks/day. Matching is identical to the old pgrep -f pattern.

How verified

• nix flake check green (unit-tests, formatting, lint).
• Full suite 235 tests pass; 7 new tests (5 tail-reader edge cases incl. reverse-read with missing trailing newline and older-turn precedence; 2 single-scan discovery assertions, one asserting a constant subprocess-fork count).
• Before/after microbenchmarks on synthetic large transcripts and subprocess-count assertions, recorded in the commits and PERF_TRACKER.md.
• Behavior-preserving: the workflow independently confirmed the hook fix over 800 fuzz trials with zero decision mismatches vs the old full parse.

Not merged

Base main, for review only.