fix(continuous-learning-v2): serialize the non-survival streak under the lazy-start lock

observe.sh runs on every tool call, so the streak read-modify-write could race
between concurrent invocations -- losing an increment or logging the warning
twice. That is the same class of bug the signal counter hit in #2296, and this
repo's rule is to never fall back to an unlocked read-modify-write.

Rather than add a second lock, move the increment into _START_OBSERVER_LOGGED.
All three of its call sites already run inside the lazy-start lock
(flock / lockfile / mkdir), so the update is serialized with no new machinery.
Counting at the restart instead of at detection also means N racing hooks
record one death rather than N.

The reset stays in the caller: it is an idempotent unlink, not a
read-modify-write, so it needs no lock.

Adds a regression case pinning the increment inside _START_OBSERVER_LOGGED and
asserting all three call sites remain locked.

Author: gaurav0107

skills/continuous-learning-v2/hooks/observe.sh

@@ -375,6 +375,14 @@ _REMOVE_FILE_IF_PRESENT() {
 _START_OBSERVER_LOGGED() {
   local bootstrap_log="${PROJECT_DIR}/observer-start.log"
   mkdir -p "$PROJECT_DIR"
+  # Every call site below sits inside the lazy-start lock (flock / lockfile /
+  # mkdir), so the streak read-modify-write in _NOTE_OBSERVER_NOSURVIVE is
+  # serialized here without a second lock -- concurrent hook invocations cannot
+  # lose an increment or double-log the warning. Counting at the restart (rather
+  # than at detection) also means N racing hooks record one death, not N.
+  if [ "${OBSERVER_DIED:-false}" = "true" ]; then
+    _NOTE_OBSERVER_NOSURVIVE
+  fi
   "${SKILL_ROOT}/agents/start-observer.sh" start >> "$bootstrap_log" 2>&1 || true
 }
 
@@ -481,12 +489,12 @@ if [ "$OBSERVER_ENABLED" = "true" ]; then
   if _CHECK_OBSERVER_RUNNING "${PROJECT_DIR}/.observer.pid"; then OBSERVER_ALIVE=true; fi
   if _CHECK_OBSERVER_RUNNING "${CONFIG_DIR}/.observer.pid"; then OBSERVER_ALIVE=true; fi
 
-  # Count non-survival once per hook invocation, not once per PID file: the
-  # double-check calls below run after the stale files are already gone.
+  # A live observer clears the streak so a later one-off crash does not inherit
+  # an old count. This is an idempotent unlink, not a read-modify-write, so it
+  # needs no lock. The matching increment runs inside the lazy-start lock, in
+  # _START_OBSERVER_LOGGED.
   if [ "$OBSERVER_ALIVE" = "true" ]; then
     _RESET_OBSERVER_NOSURVIVE_STREAK
-  elif [ "$OBSERVER_DIED" = "true" ]; then
-    _NOTE_OBSERVER_NOSURVIVE
   fi
 
   # Check if observer is now running after cleanup

tests/hooks/observe-nosurvive-warning.test.js

@@ -217,6 +217,24 @@ test('observe.sh records non-survival when clearing a live-looking stale PID', (
   );
 });
 
+test('the streak increment runs under the lazy-start lock, never unlocked', () => {
+  const content = fs.readFileSync(observeShPath, 'utf8');
+  // observe.sh fires on every tool call, so an unlocked read-modify-write on
+  // the streak file would lose increments or double-log the warning -- the same
+  // race the signal counter hit in #2296. The increment must therefore live in
+  // _START_OBSERVER_LOGGED, which every call site invokes inside the
+  // flock/lockfile/mkdir lazy-start lock.
+  const starter = content.match(/_START_OBSERVER_LOGGED\(\)\s*\{[\s\S]*?\n\}/);
+  assert.ok(starter, 'observe.sh should still define _START_OBSERVER_LOGGED');
+  assert.ok(
+    starter[0].includes('_NOTE_OBSERVER_NOSURVIVE'),
+    'the streak increment should run inside _START_OBSERVER_LOGGED, under the lazy-start lock'
+  );
+  // Every _START_OBSERVER_LOGGED call site must be inside a lock branch.
+  const callSites = content.split('\n').filter((line) => /^\s+_START_OBSERVER_LOGGED\s*$/.test(line));
+  assert.strictEqual(callSites.length, 3, 'expected the three locked lazy-start call sites');
+});
+
 test('the non-survival warning is threshold-gated, not logged every call', () => {
   const content = fs.readFileSync(observeShPath, 'utf8');
   assert.ok(