claudecode-omc 5.6.7 → 5.9.1

package/bundled/upstream/ecc/commands/react-test.md

@@ -0,0 +1,265 @@
+---
+description: Enforce TDD workflow for React. Write React Testing Library tests first (behavior-focused, accessibility-first), then implement components. Detects Vitest or Jest and verifies coverage targets.
+---
+
+# React TDD Command
+
+This command enforces test-driven development for React using React Testing Library plus Vitest or Jest, detected at runtime.
+
+## What This Command Does
+
+1. **Define Component Signature**: Scaffold the component, prop type, and exports
+2. **Write Behavior Tests First**: RTL queries (role-first), `userEvent`, MSW for network — RED
+3. **Run Tests**: Verify they fail for the right reason
+4. **Implement Minimal Code**: Just enough to pass — GREEN
+5. **Refactor**: Improve while keeping tests green
+6. **Check Coverage**: Hit the targets in [rules/react/testing.md](../rules/react/testing.md)
+
+## When to Use
+
+Use `/react-test` when:
+
+- Implementing a new React component or custom hook
+- Adding test coverage to an untested component
+- Fixing a bug (write failing test first that reproduces it)
+- Building forms, state machines, or accessibility-critical UI
+- Onboarding to RTL + Vitest/Jest workflow
+
+## TDD Cycle
+
+```
+RED      -> Write failing test for the next behavior
+GREEN    -> Implement minimal component code to pass
+REFACTOR -> Improve component, tests stay green
+REPEAT   -> Next behavior
+```
+
+## Runner Detection
+
+```bash
+test -f vitest.config.ts -o -f vitest.config.js -o -f vite.config.ts   # Vitest
+grep -l '"jest"' package.json                                          # Jest
+```
+
+Prefer Vitest for new Vite-based projects; respect Jest for existing setups.
+
+## Example Session
+
+````text
+User: /react-test I need a SearchInput component with debounced search
+
+Agent:
+# TDD Session: SearchInput
+
+## Step 1: Define Signature
+
+```tsx
+// src/components/SearchInput.tsx
+type Props = {
+  onSearch: (query: string) => void;
+  placeholder?: string;
+  debounceMs?: number;
+};
+
+export function SearchInput({ onSearch, placeholder, debounceMs }: Props) {
+  throw new Error("not implemented");
+}
+```
+
+## Step 2: Write Behavior Tests (RED)
+
+```tsx
+// src/components/SearchInput.test.tsx
+import { describe, expect, test, vi } from "vitest";
+import { render, screen } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+import { SearchInput } from "./SearchInput";
+
+describe("SearchInput", () => {
+  test("renders with placeholder", () => {
+    render(<SearchInput onSearch={() => {}} placeholder="Search users" />);
+    expect(screen.getByPlaceholderText("Search users")).toBeInTheDocument();
+  });
+
+  test("calls onSearch after typing", async () => {
+    vi.useFakeTimers();
+    const user = userEvent.setup({ advanceTimers: vi.advanceTimersByTime });
+    const onSearch = vi.fn();
+    render(<SearchInput onSearch={onSearch} debounceMs={300} />);
+
+    await user.type(screen.getByRole("textbox"), "alice");
+
+    expect(onSearch).not.toHaveBeenCalled();        // before debounce
+    vi.advanceTimersByTime(300);
+    expect(onSearch).toHaveBeenCalledWith("alice"); // after debounce
+
+    vi.useRealTimers();
+  });
+
+  test("does not call onSearch when typing pauses then continues", async () => {
+    vi.useFakeTimers();
+    const user = userEvent.setup({ advanceTimers: vi.advanceTimersByTime });
+    const onSearch = vi.fn();
+    render(<SearchInput onSearch={onSearch} debounceMs={300} />);
+
+    await user.type(screen.getByRole("textbox"), "ali");
+    vi.advanceTimersByTime(200);                    // mid-debounce
+    await user.type(screen.getByRole("textbox"), "ce");
+    vi.advanceTimersByTime(300);
+
+    expect(onSearch).toHaveBeenCalledTimes(1);
+    expect(onSearch).toHaveBeenCalledWith("alice");
+
+    vi.useRealTimers();
+  });
+
+  test("is keyboard reachable and accessible", () => {
+    render(<SearchInput onSearch={() => {}} />);
+    const input = screen.getByRole("textbox");
+    input.focus();
+    expect(input).toHaveFocus();
+  });
+});
+```
+
+## Step 3: Run Tests — Verify FAIL
+
+```bash
+$ vitest run src/components/SearchInput.test.tsx
+
+× src/components/SearchInput.test.tsx (4 tests) ✘ Error: not implemented
+```
+
+✓ Tests fail as expected.
+
+## Step 4: Implement Minimal Code (GREEN)
+
+```tsx
+import { useEffect, useState } from "react";
+
+export function SearchInput({ onSearch, placeholder, debounceMs = 300 }: Props) {
+  const [query, setQuery] = useState("");
+
+  useEffect(() => {
+    const id = setTimeout(() => onSearch(query), debounceMs);
+    return () => clearTimeout(id);
+  }, [query, onSearch, debounceMs]);
+
+  return (
+    <input
+      type="text"
+      value={query}
+      placeholder={placeholder}
+      onChange={(e) => setQuery(e.target.value)}
+    />
+  );
+}
+```
+
+## Step 5: Run Tests — Verify PASS
+
+```bash
+$ vitest run src/components/SearchInput.test.tsx
+
+✓ src/components/SearchInput.test.tsx (4 tests) 47ms
+```
+
+## Step 6: Coverage
+
+```bash
+$ vitest run --coverage src/components/SearchInput.test.tsx
+
+% Stmts: 100  % Branch: 100  % Funcs: 100  % Lines: 100
+```
+
+## TDD Complete!
+````
+
+## Test Patterns
+
+### Behavior, not implementation
+
+Use `getByRole`, `getByLabelText`, `getByText`. Avoid `container.querySelector` and asserting on component state.
+
+### `userEvent.setup()` per test
+
+```tsx
+const user = userEvent.setup();
+await user.click(screen.getByRole("button", { name: /save/i }));
+```
+
+### MSW for network
+
+```tsx
+beforeAll(() => server.listen({ onUnhandledRequest: "error" }));
+afterEach(() => server.resetHandlers());
+afterAll(() => server.close());
+
+server.use(http.post("/api/users", () => HttpResponse.json({ id: "1" }, { status: 201 })));
+```
+
+### Custom hooks
+
+```tsx
+const { result } = renderHook(() => useCounter(0));
+act(() => result.current.increment());
+expect(result.current.count).toBe(1);
+```
+
+### Accessibility
+
+```tsx
+import { axe } from "vitest-axe";
+expect(await axe(container)).toHaveNoViolations();
+```
+
+## Coverage Targets
+
+| Layer | Target |
+|---|---|
+| Pure utilities | >=90% |
+| Custom hooks | >=85% |
+| Presentational components | >=80% |
+| Container components | >=70% |
+| Pages | E2E covered separately |
+
+Configure in `vitest.config.ts` / `jest.config.js` to enforce thresholds in CI.
+
+## Anti-Patterns to Avoid
+
+- `container.querySelector(...)` — bypasses accessibility queries
+- Asserting on render count
+- Mocking `react` itself (`jest.mock("react", ...)`)
+- Mocking child components by default (mock only when child has heavy side effects)
+- Ignoring `act()` warnings — they signal real bugs
+- Snapshot tests of rendered components (brittle, rubber-stamped) — use Playwright/Cypress visual diff instead
+
+## Test Commands
+
+```bash
+# Vitest
+vitest                              # watch
+vitest run                          # one-shot
+vitest run --coverage               # with coverage
+vitest run path/to/file.test.tsx    # single file
+
+# Jest
+jest --watch
+jest --coverage
+jest path/to/file.test.tsx
+
+# CI mode
+CI=true vitest run --coverage
+```
+
+## Related Commands
+
+- `/react-build` — fix build errors before running tests
+- `/react-review` — review after implementation
+- `verification-loop` skill — full verification loop
+
+## Related
+
+- Skills: `skills/react-testing/`, `skills/tdd-workflow/`, `skills/accessibility/`, `skills/e2e-testing/`
+- Rules: `rules/react/testing.md`
+- Agents: `react-reviewer` (reviews test quality), `tdd-guide` (enforces TDD process)

package/bundled/upstream/ecc/skills/benchmark-optimization-loop/SKILL.md

@@ -0,0 +1,69 @@
+---
+name: benchmark-optimization-loop
+description: Use when the user asks to make something faster, try many variants, run recursive optimization, benchmark latency/throughput/cost, or choose the best implementation by repeated measured tests.
+origin: ECC
+tools: Read, Write, Edit, Bash, Grep, Glob
+---
+
+# Benchmark Optimization Loop
+
+Use this skill to convert "make it 20x faster" or "try 50 recursive
+optimizations" into a bounded measured loop that can actually improve a system.
+
+## Required Baseline
+
+Do not optimize until these exist:
+
+- the operation being optimized;
+- the correctness gate that must stay green;
+- the metric: wall time, p95 latency, rows/sec, cost/run, memory, error rate;
+- the current baseline;
+- the search budget: max variants, max time, max spend, max data impact.
+
+If the user asks for an unrealistic target, keep the ambition but make the loop
+bounded and measurable.
+
+## Loop
+
+1. Measure the baseline.
+2. Identify bottlenecks from evidence.
+3. Generate variants that test one hypothesis each.
+4. Run variants with the same input shape.
+5. Reject variants that fail correctness, safety, or reproducibility.
+6. Promote the fastest safe variant.
+7. Codify the winning path in a script, command, test, config, or doc.
+8. Rerun the baseline and winner to confirm the delta.
+
+## Variant Table
+
+Track variants like this:
+
+```text
+Variant | Hypothesis | Command | Time | Correct? | Notes
+baseline | current path | npm run job | 120s | yes | stable
+batch-500 | fewer round trips | npm run job -- --batch 500 | 42s | yes | winner
+parallel-8 | more workers | npm run job -- --workers 8 | 31s | no | rate limited
+```
+
+## Recursive Search
+
+For recursive or hyperparameter work:
+
+- persist every run to a ledger;
+- compare against the prior accepted winner, not only the previous run;
+- keep a holdout or replay check;
+- stop when improvement is within noise, correctness fails, cost exceeds the
+  budget, or the search starts changing more variables than it can explain.
+
+Use phrases like "best measured safe variant" instead of "global optimum" unless
+the search space was actually exhaustive.
+
+## Promotion Gate
+
+A variant cannot become the new default until:
+
+- correctness tests pass;
+- the performance delta is repeated or explained;
+- rollback is obvious;
+- the change is encoded in source control or a durable runbook;
+- the final summary includes exact commands and measurements.

package/bundled/upstream/ecc/skills/blender-motion-state-inspection/SKILL.md

@@ -0,0 +1,164 @@
+---
+name: blender-motion-state-inspection
+description: Use this skill when inspecting Blender characters, rigs, poses, animation retargeting, ground contact, facing direction, or model-vs-motion alignment where screenshots alone are not enough.
+origin: ECC
+tools: Read, Write, Edit, Bash, Grep, Glob
+---
+
+# Blender Motion State Inspection
+
+## When to Use
+
+- A Blender character looks twisted, mirrored, flattened, offset, or foot-sliding in an animation.
+- A user asks whether an imported avatar, armature, or retargeted motion matches an expected pose.
+- You need to compare rendered evidence with structured facts such as bones, bounding boxes, contacts, and facing vectors.
+- A workflow depends on deciding whether a model is a character, prop, proxy mesh, control rig, or broken import.
+
+## Core Principle
+
+Do not judge animated 3D assets only from screenshots. Screenshots are review evidence, but they hide axis conventions, bone names, object scale, local transforms, parented meshes, material slots, and frame-by-frame contact state.
+
+First extract structured Blender state, then use viewport screenshots or renders to confirm what the facts imply.
+
+## How It Works
+
+1. Establish the clean scene and asset baseline before judging motion.
+2. Extract structured facts from Blender using an exporter or Blender Python run inside Blender's own interpreter.
+3. Sample the frames most likely to expose contact, orientation, scale, and retargeting errors.
+4. Compare the measured facts against the user's expected pose, direction, ground plane, and render goal.
+5. Return a concise report that separates confirmed facts, likely causes, and required fixes.
+
+## Inspection Workflow
+
+1. Inventory the scene.
+   - List meshes, armatures, empties, cameras, lights, modifiers, parent relationships, and hidden objects.
+   - Separate character meshes from helper/proxy geometry before judging the avatar.
+   - Record object-space and world-space bounding boxes.
+
+2. Identify the skeleton.
+   - Capture armature names, pose bones, bone heads/tails, roll, parent chains, constraints, and rest-pose axes.
+   - Map semantic bones such as hips, spine, neck, head, shoulders, elbows, hands, thighs, knees, ankles, and feet.
+   - Flag missing left/right pairs and unusual naming schemes.
+
+3. Determine forward, up, and side axes.
+   - Use the pelvis, spine, shoulders, hips, head, and feet together; do not rely on a single mesh normal.
+   - Compare local armature axes with world axes and imported file conventions such as glTF Y-up vs Blender Z-up.
+   - Mark likely mirrored or backwards imports when face/head/feet direction conflicts with root motion.
+
+4. Sample animation frames.
+   - Inspect first, middle, contact, airborne, and extreme frames.
+   - Record root location, root heading, pelvis height, torso lean, limb directions, foot clearance, and mesh bounds.
+   - For long or fast motion, sample more densely around flips, landings, turns, collisions, and floor contacts.
+
+5. Check model integrity before retargeting blame.
+   - Confirm the clean baseline shape before applying animation.
+   - Preserve original mesh, materials, armature, and skinning unless the user explicitly asks for repair.
+   - Treat unexplained sphere-like blobs, giant proxy meshes, or crushed bodies as import/selection issues until proven otherwise.
+
+6. Diagnose contact and motion issues.
+   - Ground penetration: compare lowest foot or shoe vertices with floor height per frame.
+   - Foot sliding: compare foot world positions across planted frames.
+   - Leg crossover: compare left/right thigh, knee, ankle, and foot side ordering.
+   - Twist damage: compare bone swing direction separately from roll/twist around the limb axis.
+   - Scale drift: compare animated mesh bounds against the clean baseline bounds.
+
+7. Report facts before opinions.
+   - Include frame numbers, object names, bone names, world coordinates, and thresholds.
+   - Separate confirmed failures from visual suspicions.
+   - Attach screenshots only after the structured state explains what to look for.
+
+## Recommended Report Shape
+
+```markdown
+## Blender Motion Inspection
+
+### Scene Inventory
+- Character candidates:
+- Armatures:
+- Helper/proxy objects:
+- Cameras/lights:
+
+### Orientation
+- World up:
+- Character forward:
+- Root heading:
+- Mirrored/backwards risk:
+
+### Baseline Integrity
+- Clean mesh bounds:
+- Animated mesh bounds:
+- Materials/skin preserved:
+- Suspicious non-character meshes:
+
+### Frame Findings
+| Frame | Finding | Evidence |
+| --- | --- | --- |
+| 1 | Clean baseline pose | hips/spine/feet aligned |
+| 96 | Foot penetrates floor | left_foot min_z = -0.04 |
+
+### Verdict
+- Pass/fail:
+- Required fix:
+- Render readiness:
+```
+
+## Examples
+
+### Walk Cycle With Foot Sliding
+
+Scenario: a retargeted character appears to skate during a walk cycle, but the front camera angle makes the foot contact hard to judge.
+
+Apply the workflow:
+- Inventory the scene: character mesh `HeroBody`, armature `HeroRig`, ground plane `Floor`, no hidden proxy meshes.
+- Identify the skeleton: semantic feet are `foot.L` and `foot.R`; hips are `pelvis`; root bone is `root`.
+- Sample animation frames: inspect frames 1, 18, 24, 30, 42, and 48 around planted-foot moments.
+- Diagnose contact and motion issues: compare world-space foot locations during planted frames.
+
+Extracted facts:
+
+| Frame | Fact | Evidence |
+| --- | --- | --- |
+| 18 | Left foot is planted | `foot.L min_z = 0.004`, toe and heel both near floor |
+| 24 | Left foot slides while planted | `foot.L x = 0.21 -> 0.28` over six frames |
+| 30 | Pelvis keeps moving forward | `pelvis y = 1.14 -> 1.31` |
+
+Verdict: fail for render readiness. The motion needs foot-lock cleanup or retargeting constraint review; the body mesh does not need proportion changes.
+
+### Backwards Imported Character
+
+Scenario: a character looks correct in a still frame, but the animation moves opposite the expected travel direction.
+
+Apply the workflow:
+- Determine forward, up, and side axes: compare head, chest, feet, and root motion.
+- Sample animation frames: inspect frame 1 and the midpoint of the travel path.
+- Report facts before opinions: include the root heading and model-facing direction separately.
+
+Extracted facts:
+
+| Frame | Fact | Evidence |
+| --- | --- | --- |
+| 1 | Character face points toward world `-Y` | head/chest vector from `neck` to `head` resolves to `-Y` |
+| 72 | Root motion travels toward world `+Y` | `root y = 0.0 -> 2.8` |
+| 72 | Feet remain visually forward-facing opposite travel | toe bones point `-Y` while displacement is `+Y` |
+
+Verdict: likely backwards import or retargeting forward-axis mismatch. Fix the import/retarget axis mapping before editing animation curves.
+
+## Practical Thresholds
+
+- Assume Blender's default meter-scale units unless the scene unit scale says otherwise.
+- Treat ground penetration above 1-2 cm as visible unless the floor is soft or intentionally stylized.
+- Treat a sudden scale change above 5% as a likely rig, constraint, or transform inheritance problem.
+- Treat left/right ankle side-order flips during airborne inverted motion as leg crossover risk even if it recovers later.
+- Treat root heading jumps above 30 degrees per frame as suspicious unless the source motion includes a snap turn.
+
+## Anti-Patterns
+
+- Do not modify body proportions to force pose matching unless the task is explicitly mesh repair.
+- Do not bake away the clean baseline before recording it.
+- Do not use one rendered camera angle as proof that a pose is correct.
+- Do not delete helper objects until you have recorded why they are not part of the character.
+- Do not assume an avatar faces +Y, -Y, +X, or -X without checking head, feet, torso, and root motion together.
+
+## Tooling Notes
+
+If a Blender state exporter is available, prefer JSON that includes meshes, armatures, pose bones, materials, contacts, bounding boxes, and sampled animation frames. If no exporter exists, run a small Blender Python script through Blender itself, for example `blender --background scene.blend --python collect_motion_state.py`, because `bpy` is not available in a normal system Python interpreter.

package/bundled/upstream/ecc/skills/canary-watch/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: canary-watch
-description: Use this skill to monitor a deployed URL for regressions after deploys, merges, or dependency upgrades.
+description: Use this skill to monitor and verify a deployed URL after releases — checks HTTP endpoints, SSE streams, static assets, console errors, and performance regressions after deploys, merges, or dependency upgrades. Smoke / canary / post-deploy verification.
 origin: ECC
 ---
 
@@ -27,6 +27,8 @@ Monitors a deployed URL for regressions. Runs in a loop until stopped or until t
 4. Performance — LCP/CLS/INP regression vs baseline?
 5. Content — did key elements disappear? (h1, nav, footer, CTA)
 6. API Health — are critical endpoints responding within SLA?
+7. Static Assets — are JS, CSS, image, and font requests returning 2xx/3xx with expected content types?
+8. SSE Streams — do event-stream endpoints connect and receive an initial event or heartbeat?
 ```
 
 ### Watch Modes
@@ -54,12 +56,16 @@ critical:  # immediate alert
   - Console error count > 5 (new errors only)
   - LCP > 4s
   - API endpoint returns 5xx
+  - Static asset returns 4xx/5xx
+  - SSE endpoint cannot connect or drops before first heartbeat
 
 warning:   # flag in report
   - LCP increased > 500ms from baseline
   - CLS > 0.1
   - New console warnings
   - Response time > 2x baseline
+  - Static asset content type changed unexpectedly
+  - SSE heartbeat latency > 2x baseline
 
 info:      # log only
   - Minor performance variance
@@ -87,6 +93,8 @@ When a critical threshold is crossed:
 | LCP | 1.8s ✓ | 1.6s | +200ms |
 | CLS | 0.01 ✓ | 0.01 | — |
 | API /health | 145ms ✓ | 120ms | +25ms |
+| Static assets | 42/42 ✓ | 42/42 | — |
+| SSE /events | connected ✓ | connected | +80ms heartbeat |
 
 ### No regressions detected. Deploy is clean.
 ```

package/bundled/upstream/ecc/skills/continuous-learning-v2/hooks/observe.sh

@@ -116,7 +116,13 @@ except(KeyError, TypeError, ValueError):
 # If cwd was provided in stdin, use it for project detection
 if [ -n "$STDIN_CWD" ] && [ -d "$STDIN_CWD" ]; then
   _GIT_ROOT=$(git -C "$STDIN_CWD" rev-parse --show-toplevel 2>/dev/null || true)
-  export CLAUDE_PROJECT_DIR="${_GIT_ROOT:-$STDIN_CWD}"
+  if [ -n "$_GIT_ROOT" ]; then
+    export CLAUDE_PROJECT_DIR="$_GIT_ROOT"
+    unset CLV2_NO_PROJECT
+  else
+    unset CLAUDE_PROJECT_DIR
+    export CLV2_NO_PROJECT=1
+  fi
 fi
 
 # ─────────────────────────────────────────────
@@ -333,6 +339,19 @@ print(json.dumps(observation))
 # Use flock for atomic check-then-act to prevent race conditions
 # Fallback for macOS (no flock): use lockfile or skip
 LAZY_START_LOCK="${PROJECT_DIR}/.observer-start.lock"
+_REMOVE_FILE_IF_PRESENT() {
+  local target="$1"
+  if [ -n "$target" ] && [ -e "$target" ]; then
+    rm -- "$target" 2>/dev/null || true
+  fi
+}
+
+_START_OBSERVER_LOGGED() {
+  local bootstrap_log="${PROJECT_DIR}/observer-start.log"
+  mkdir -p "$PROJECT_DIR"
+  "${SKILL_ROOT}/agents/start-observer.sh" start >> "$bootstrap_log" 2>&1 || true
+}
+
 _CHECK_OBSERVER_RUNNING() {
   local pid_file="$1"
   if [ -f "$pid_file" ]; then
@@ -341,7 +360,7 @@ _CHECK_OBSERVER_RUNNING() {
     # Validate PID is a positive integer (>1) to prevent signaling invalid targets
     case "$pid" in
       ''|*[!0-9]*|0|1)
-        rm -f "$pid_file" 2>/dev/null || true
+        _REMOVE_FILE_IF_PRESENT "$pid_file"
         return 1
         ;;
     esac
@@ -349,7 +368,7 @@ _CHECK_OBSERVER_RUNNING() {
       return 0  # Process is alive
     fi
     # Stale PID file - remove it
-    rm -f "$pid_file" 2>/dev/null || true
+    _REMOVE_FILE_IF_PRESENT "$pid_file"
   fi
   return 1  # No PID file or process dead
 }
@@ -396,7 +415,7 @@ if [ "$OBSERVER_ENABLED" = "true" ]; then
         _CHECK_OBSERVER_RUNNING "${PROJECT_DIR}/.observer.pid" || true
         _CHECK_OBSERVER_RUNNING "${CONFIG_DIR}/.observer.pid" || true
         if [ ! -f "${PROJECT_DIR}/.observer.pid" ] && [ ! -f "${CONFIG_DIR}/.observer.pid" ]; then
-          nohup "${SKILL_ROOT}/agents/start-observer.sh" start >/dev/null 2>&1 &
+          _START_OBSERVER_LOGGED
         fi
       ) 9>"$LAZY_START_LOCK"
     else
@@ -404,14 +423,14 @@ if [ "$OBSERVER_ENABLED" = "true" ]; then
       if command -v lockfile >/dev/null 2>&1; then
         # Use subshell to isolate exit and add trap for cleanup
         (
-          trap 'rm -f "$LAZY_START_LOCK" 2>/dev/null || true' EXIT
+          trap '_REMOVE_FILE_IF_PRESENT "$LAZY_START_LOCK"' EXIT
           lockfile -r 1 -l 30 "$LAZY_START_LOCK" 2>/dev/null || exit 0
           _CHECK_OBSERVER_RUNNING "${PROJECT_DIR}/.observer.pid" || true
           _CHECK_OBSERVER_RUNNING "${CONFIG_DIR}/.observer.pid" || true
           if [ ! -f "${PROJECT_DIR}/.observer.pid" ] && [ ! -f "${CONFIG_DIR}/.observer.pid" ]; then
-            nohup "${SKILL_ROOT}/agents/start-observer.sh" start >/dev/null 2>&1 &
+            _START_OBSERVER_LOGGED
           fi
-          rm -f "$LAZY_START_LOCK" 2>/dev/null || true
+          _REMOVE_FILE_IF_PRESENT "$LAZY_START_LOCK"
         )
       else
         # POSIX fallback: mkdir is atomic -- fails if dir already exists
@@ -421,7 +440,7 @@ if [ "$OBSERVER_ENABLED" = "true" ]; then
           _CHECK_OBSERVER_RUNNING "${PROJECT_DIR}/.observer.pid" || true
           _CHECK_OBSERVER_RUNNING "${CONFIG_DIR}/.observer.pid" || true
           if [ ! -f "${PROJECT_DIR}/.observer.pid" ] && [ ! -f "${CONFIG_DIR}/.observer.pid" ]; then
-            nohup "${SKILL_ROOT}/agents/start-observer.sh" start >/dev/null 2>&1 &
+            _START_OBSERVER_LOGGED
           fi
         )
       fi
@@ -459,7 +478,10 @@ if [ "$should_signal" -eq 1 ]; then
       observer_pid=$(cat "$pid_file" 2>/dev/null || true)
       # Validate PID is a positive integer (>1)
       case "$observer_pid" in
-        ''|*[!0-9]*|0|1) rm -f "$pid_file" 2>/dev/null || true; continue ;;
+        ''|*[!0-9]*|0|1)
+          _REMOVE_FILE_IF_PRESENT "$pid_file"
+          continue
+          ;;
       esac
       # Deduplicate: skip if already signaled this pass
       case "$signaled_pids" in