oh-my-opencode 4.4.0 → 4.5.1

package/.agents/skills/work-with-pr-workspace/iteration-1/eval-1/without_skill/outputs/pr-description.md

@@ -0,0 +1,50 @@
+# PR Description
+
+**Title:** feat: add `maxBackgroundAgents` config to limit total simultaneous background agents
+
+**Body:**
+
+## Summary
+
+- Add `maxBackgroundAgents` field to `BackgroundTaskConfigSchema` that enforces a global ceiling on total running background agents across all models/providers
+- Modify `ConcurrencyManager` to track global count and enforce the limit alongside existing per-model limits
+- Add schema validation tests and concurrency enforcement tests
+
+## Motivation
+
+Currently, concurrency is only limited per model/provider key (default 5 per key). On resource-constrained machines or when using many different models, the total number of background agents can grow unbounded (5 per model x N models). This config option lets users set a hard ceiling.
+
+## Changes
+
+### Schema (`src/config/schema/background-task.ts`)
+- Added `maxBackgroundAgents: z.number().int().min(1).optional()` to `BackgroundTaskConfigSchema`
+- Grouped with existing limit fields (`maxDepth`, `maxDescendants`)
+
+### ConcurrencyManager (`src/features/background-agent/concurrency.ts`)
+- Added `globalCount` tracking total active agents across all concurrency keys
+- Added `getGlobalLimit()` reading `maxBackgroundAgents` from config (defaults to `Infinity` = no global limit)
+- Modified `acquire()` to check both per-model AND global capacity
+- Modified `release()` to decrement global count and drain cross-model waiters blocked by global limit
+- Modified `clear()` to reset global state
+- Added `getGlobalCount()` / `getGlobalQueueLength()` for testing
+
+### Tests
+- `src/config/schema/background-task.test.ts`: 6 test cases for schema validation (valid, min boundary, below min, negative, non-integer, undefined)
+- `src/features/background-agent/concurrency.test.ts`: 8 test cases for global limit enforcement (cross-model blocking, release unblocking, per-model vs global interaction, no-config default, clear reset)
+
+## Config Example
+
+```jsonc
+{
+  "background_task": {
+    "maxBackgroundAgents": 5,
+    "defaultConcurrency": 3
+  }
+}
+```
+
+## Backward Compatibility
+
+- When `maxBackgroundAgents` is not set (default), no global limit is enforced - behavior is identical to before
+- Existing `defaultConcurrency`, `providerConcurrency`, and `modelConcurrency` continue to work unchanged
+- No config migration needed

package/.agents/skills/work-with-pr-workspace/iteration-1/eval-1/without_skill/outputs/verification-strategy.md

@@ -0,0 +1,111 @@
+# Verification Strategy
+
+## 1. Static Analysis
+
+### TypeScript Typecheck
+```bash
+bun run typecheck
+```
+- Verify no type errors introduced
+- `BackgroundTaskConfig` type is inferred from Zod schema, so adding the field automatically updates the type
+- All existing consumers of `BackgroundTaskConfig` remain compatible (new field is optional)
+
+### LSP Diagnostics
+Check changed files for errors:
+- `src/config/schema/background-task.ts`
+- `src/features/background-agent/concurrency.ts`
+- `src/config/schema/background-task.test.ts`
+- `src/features/background-agent/concurrency.test.ts`
+
+## 2. Unit Tests
+
+### Schema Validation Tests
+```bash
+bun test src/config/schema/background-task.test.ts
+```
+
+| Test Case | Input | Expected |
+|-----------|-------|----------|
+| Valid value (10) | `{ maxBackgroundAgents: 10 }` | Parses to `10` |
+| Minimum boundary (1) | `{ maxBackgroundAgents: 1 }` | Parses to `1` |
+| Below minimum (0) | `{ maxBackgroundAgents: 0 }` | Throws `ZodError` |
+| Negative (-1) | `{ maxBackgroundAgents: -1 }` | Throws `ZodError` |
+| Non-integer (2.5) | `{ maxBackgroundAgents: 2.5 }` | Throws `ZodError` |
+| Not provided | `{}` | Field is `undefined` |
+
+### ConcurrencyManager Tests
+```bash
+bun test src/features/background-agent/concurrency.test.ts
+```
+
+| Test Case | Setup | Expected |
+|-----------|-------|----------|
+| No config = no global limit | No `maxBackgroundAgents` | `getGlobalLimit()` returns `Infinity` |
+| Config respected | `maxBackgroundAgents: 3` | `getGlobalLimit()` returns `3` |
+| Cross-model blocking | Global limit 2, acquire model-a + model-b, try model-c | model-c blocks |
+| Under-limit allows | Global limit 3, acquire 3 different models | All succeed |
+| Per-model + global interaction | Per-model 1, global 3, acquire model-a twice | Blocked by per-model, not global |
+| Release unblocks | Global limit 1, acquire model-a, queue model-b, release model-a | model-b proceeds |
+| No global limit = no enforcement | No config, acquire 6 different models | All succeed |
+| Clear resets global count | Acquire 2, clear | `getGlobalCount()` is 0 |
+
+### Existing Test Regression
+```bash
+bun test src/features/background-agent/concurrency.test.ts
+bun test src/config/schema/background-task.test.ts
+bun test src/config/schema.test.ts
+```
+All existing tests must continue to pass unchanged.
+
+## 3. Integration Verification
+
+### Config Loading Path
+Verify the config flows correctly through the system:
+
+1. **Schema → Type**: `BackgroundTaskConfig` type auto-includes `maxBackgroundAgents` via `z.infer`
+2. **Config file → Schema**: `loadConfigFromPath()` in `plugin-config.ts` uses `OhMyOpenCodeConfigSchema.safeParse()` which includes `BackgroundTaskConfigSchema`
+3. **Config → Manager**: `create-managers.ts` passes `pluginConfig.background_task` to `BackgroundManager` constructor
+4. **Manager → ConcurrencyManager**: `BackgroundManager` constructor passes config to `new ConcurrencyManager(config)`
+5. **ConcurrencyManager → Enforcement**: `acquire()` reads `config.maxBackgroundAgents` via `getGlobalLimit()`
+
+No changes needed in steps 2-4 since the field is optional and the existing plumbing passes the entire `BackgroundTaskConfig` object.
+
+### Manual Config Test
+Create a test config to verify parsing:
+```bash
+echo '{ "background_task": { "maxBackgroundAgents": 3 } }' | bun -e "
+  const { BackgroundTaskConfigSchema } = require('./src/config/schema/background-task');
+  const result = BackgroundTaskConfigSchema.safeParse(JSON.parse(require('fs').readFileSync('/dev/stdin', 'utf-8')).background_task);
+  console.log(result.success, result.data);
+"
+```
+
+## 4. Build Verification
+
+```bash
+bun run build
+```
+- Verify build succeeds
+- Schema JSON output includes the new field (if applicable)
+
+## 5. Edge Cases to Verify
+
+| Edge Case | Expected Behavior |
+|-----------|-------------------|
+| `maxBackgroundAgents` not set | No global limit enforced (backward compatible) |
+| `maxBackgroundAgents: 1` | Only 1 background agent at a time across all models |
+| `maxBackgroundAgents` > sum of all per-model limits | Global limit never triggers (per-model limits are tighter) |
+| Per-model limit tighter than global | Per-model limit blocks first |
+| Global limit tighter than per-model | Global limit blocks first |
+| Release from one model unblocks different model | Global slot freed, different model's waiter proceeds |
+| Manager shutdown with global waiters | `clear()` rejects all waiters and resets global count |
+| Concurrent acquire/release | No race conditions (single-threaded JS event loop) |
+
+## 6. CI Pipeline
+
+The existing CI workflow (`ci.yml`) will run:
+- `bun run typecheck` - type checking
+- `bun test` - all tests including new ones
+- `bun run build` - build verification
+
+No CI changes needed.

package/.agents/skills/work-with-pr-workspace/iteration-1/eval-1/without_skill/timing.json

@@ -0,0 +1 @@
+{"total_tokens": null, "duration_ms": 365000, "total_duration_seconds": 365}

package/.agents/skills/work-with-pr-workspace/iteration-1/eval-2/eval_metadata.json

@@ -0,0 +1,37 @@
+{
+  "eval_id": 2,
+  "eval_name": "bugfix-atlas-null-check",
+  "prompt": "The atlas hook has a bug where it crashes when boulder.json is missing the worktree_path field. Fix it and land the fix as a PR. Make sure CI passes.",
+  "assertions": [
+    {
+      "id": "worktree-isolation",
+      "text": "Plan uses git worktree in a sibling directory",
+      "type": "manual"
+    },
+    {
+      "id": "minimal-fix",
+      "text": "Fix is minimal — adds null check, doesn't refactor unrelated code",
+      "type": "manual"
+    },
+    {
+      "id": "test-added",
+      "text": "Test case added for the missing worktree_path scenario",
+      "type": "manual"
+    },
+    {
+      "id": "three-gates",
+      "text": "Verification loop includes all 3 gates: CI, review-work, Cubic",
+      "type": "manual"
+    },
+    {
+      "id": "real-atlas-files",
+      "text": "References actual atlas hook files in src/hooks/atlas/",
+      "type": "manual"
+    },
+    {
+      "id": "fix-branch-naming",
+      "text": "Branch name follows fix/ prefix convention",
+      "type": "manual"
+    }
+  ]
+}

package/.agents/skills/work-with-pr-workspace/iteration-1/eval-2/with_skill/grading.json

@@ -0,0 +1,11 @@
+{
+  "run_id": "eval-2-with_skill",
+  "expectations": [
+    {"text": "Plan uses git worktree in a sibling directory", "passed": true, "evidence": "../omo-wt/fix-atlas-worktree-path-crash"},
+    {"text": "Fix is minimal — adds null check, doesn't refactor unrelated code", "passed": true, "evidence": "3 targeted changes: readBoulderState sanitization, idle-event guard, tests"},
+    {"text": "Test case added for the missing worktree_path scenario", "passed": true, "evidence": "Tests for missing and null worktree_path"},
+    {"text": "Verification loop includes all 3 gates", "passed": true, "evidence": "Gate A (CI), Gate B (review-work), Gate C (Cubic)"},
+    {"text": "References actual atlas hook files", "passed": true, "evidence": "src/hooks/atlas/idle-event.ts, src/features/boulder-state/storage.ts"},
+    {"text": "Branch name follows fix/ prefix convention", "passed": true, "evidence": "fix/atlas-worktree-path-crash"}
+  ]
+}

package/.agents/skills/work-with-pr-workspace/iteration-1/eval-2/with_skill/outputs/code-changes.md

@@ -0,0 +1,205 @@
+# Code Changes
+
+## File 1: `src/features/boulder-state/storage.ts`
+
+**Change**: Add `worktree_path` sanitization in `readBoulderState()`
+
+```typescript
+// BEFORE (lines 29-32):
+    if (!Array.isArray(parsed.session_ids)) {
+      parsed.session_ids = []
+    }
+    return parsed as BoulderState
+
+// AFTER:
+    if (!Array.isArray(parsed.session_ids)) {
+      parsed.session_ids = []
+    }
+    if (parsed.worktree_path !== undefined && typeof parsed.worktree_path !== "string") {
+      parsed.worktree_path = undefined
+    }
+    return parsed as BoulderState
+```
+
+**Rationale**: `readBoulderState` casts raw `JSON.parse()` output as `BoulderState` without validating individual fields. When boulder.json has `"worktree_path": null` (valid JSON from manual edits, corrupted state, or external tools), the runtime type is `null` but TypeScript type says `string | undefined`. This sanitization ensures downstream code always gets the correct type.
+
+---
+
+## File 2: `src/hooks/atlas/idle-event.ts`
+
+**Change**: Add defensive string type guard before passing `worktree_path` to continuation functions.
+
+```typescript
+// BEFORE (lines 83-88 in scheduleRetry):
+      await injectContinuation({
+        ctx,
+        sessionID,
+        sessionState,
+        options,
+        planName: currentBoulder.plan_name,
+        progress: currentProgress,
+        agent: currentBoulder.agent,
+        worktreePath: currentBoulder.worktree_path,
+      })
+
+// AFTER:
+      await injectContinuation({
+        ctx,
+        sessionID,
+        sessionState,
+        options,
+        planName: currentBoulder.plan_name,
+        progress: currentProgress,
+        agent: currentBoulder.agent,
+        worktreePath: typeof currentBoulder.worktree_path === "string" ? currentBoulder.worktree_path : undefined,
+      })
+```
+
+```typescript
+// BEFORE (lines 184-188 in handleAtlasSessionIdle):
+  await injectContinuation({
+    ctx,
+    sessionID,
+    sessionState,
+    options,
+    planName: boulderState.plan_name,
+    progress,
+    agent: boulderState.agent,
+    worktreePath: boulderState.worktree_path,
+  })
+
+// AFTER:
+  await injectContinuation({
+    ctx,
+    sessionID,
+    sessionState,
+    options,
+    planName: boulderState.plan_name,
+    progress,
+    agent: boulderState.agent,
+    worktreePath: typeof boulderState.worktree_path === "string" ? boulderState.worktree_path : undefined,
+  })
+```
+
+**Rationale**: Belt-and-suspenders defense. Even though `readBoulderState` now sanitizes, direct `writeBoulderState` calls elsewhere could still produce invalid state. The `typeof` check is zero-cost and prevents any possibility of `null` or non-string values leaking through.
+
+---
+
+## File 3: `src/hooks/atlas/index.test.ts`
+
+**Change**: Add test cases for missing `worktree_path` scenarios within the existing `session.idle handler` describe block.
+
+```typescript
+    test("should inject continuation when boulder.json has no worktree_path field", async () => {
+      // given - boulder state WITHOUT worktree_path
+      const planPath = join(TEST_DIR, "test-plan.md")
+      writeFileSync(planPath, "# Plan\n- [ ] Task 1\n- [x] Task 2")
+
+      const state: BoulderState = {
+        active_plan: planPath,
+        started_at: "2026-01-02T10:00:00Z",
+        session_ids: [MAIN_SESSION_ID],
+        plan_name: "test-plan",
+      }
+      writeBoulderState(TEST_DIR, state)
+
+      const readState = readBoulderState(TEST_DIR)
+      expect(readState?.worktree_path).toBeUndefined()
+
+      const mockInput = createMockPluginInput()
+      const hook = createAtlasHook(mockInput)
+
+      // when
+      await hook.handler({
+        event: {
+          type: "session.idle",
+          properties: { sessionID: MAIN_SESSION_ID },
+        },
+      })
+
+      // then - continuation injected, no worktree context in prompt
+      expect(mockInput._promptMock).toHaveBeenCalled()
+      const callArgs = mockInput._promptMock.mock.calls[0][0]
+      expect(callArgs.body.parts[0].text).not.toContain("[Worktree:")
+      expect(callArgs.body.parts[0].text).toContain("1 remaining")
+    })
+
+    test("should handle boulder.json with worktree_path: null without crashing", async () => {
+      // given - manually write boulder.json with worktree_path: null (corrupted state)
+      const planPath = join(TEST_DIR, "test-plan.md")
+      writeFileSync(planPath, "# Plan\n- [ ] Task 1\n- [x] Task 2")
+
+      const boulderPath = join(SISYPHUS_DIR, "boulder.json")
+      writeFileSync(boulderPath, JSON.stringify({
+        active_plan: planPath,
+        started_at: "2026-01-02T10:00:00Z",
+        session_ids: [MAIN_SESSION_ID],
+        plan_name: "test-plan",
+        worktree_path: null,
+      }, null, 2))
+
+      const mockInput = createMockPluginInput()
+      const hook = createAtlasHook(mockInput)
+
+      // when
+      await hook.handler({
+        event: {
+          type: "session.idle",
+          properties: { sessionID: MAIN_SESSION_ID },
+        },
+      })
+
+      // then - should inject continuation without crash, no "[Worktree: null]"
+      expect(mockInput._promptMock).toHaveBeenCalled()
+      const callArgs = mockInput._promptMock.mock.calls[0][0]
+      expect(callArgs.body.parts[0].text).not.toContain("[Worktree: null]")
+      expect(callArgs.body.parts[0].text).not.toContain("[Worktree: undefined]")
+    })
+```
+
+---
+
+## File 4: `src/features/boulder-state/storage.test.ts` (addition to existing)
+
+**Change**: Add `readBoulderState` sanitization test.
+
+```typescript
+  describe("#given boulder.json with worktree_path: null", () => {
+    test("#then readBoulderState should sanitize null to undefined", () => {
+      // given
+      const boulderPath = join(TEST_DIR, ".sisyphus", "boulder.json")
+      writeFileSync(boulderPath, JSON.stringify({
+        active_plan: "/path/to/plan.md",
+        started_at: "2026-01-02T10:00:00Z",
+        session_ids: ["session-1"],
+        plan_name: "test-plan",
+        worktree_path: null,
+      }, null, 2))
+
+      // when
+      const state = readBoulderState(TEST_DIR)
+
+      // then
+      expect(state).not.toBeNull()
+      expect(state!.worktree_path).toBeUndefined()
+    })
+
+    test("#then readBoulderState should preserve valid worktree_path string", () => {
+      // given
+      const boulderPath = join(TEST_DIR, ".sisyphus", "boulder.json")
+      writeFileSync(boulderPath, JSON.stringify({
+        active_plan: "/path/to/plan.md",
+        started_at: "2026-01-02T10:00:00Z",
+        session_ids: ["session-1"],
+        plan_name: "test-plan",
+        worktree_path: "/valid/worktree/path",
+      }, null, 2))
+
+      // when
+      const state = readBoulderState(TEST_DIR)
+
+      // then
+      expect(state?.worktree_path).toBe("/valid/worktree/path")
+    })
+  })
+```

package/.agents/skills/work-with-pr-workspace/iteration-1/eval-2/with_skill/outputs/execution-plan.md

@@ -0,0 +1,78 @@
+# Execution Plan — Fix atlas hook crash on missing worktree_path
+
+## Phase 0: Setup
+
+1. **Create worktree from origin/dev**:
+   ```bash
+   git fetch origin dev
+   git worktree add ../omo-wt/fix-atlas-worktree-path-crash origin/dev
+   ```
+2. **Create feature branch**:
+   ```bash
+   cd ../omo-wt/fix-atlas-worktree-path-crash
+   git checkout -b fix/atlas-worktree-path-crash
+   ```
+
+## Phase 1: Implement
+
+### Step 1: Fix `readBoulderState()` in `src/features/boulder-state/storage.ts`
+- Add `worktree_path` sanitization after JSON parse
+- Ensure `worktree_path` is `string | undefined`, never `null` or other types
+- This is the root cause: raw `JSON.parse` + `as BoulderState` cast allows type violations at runtime
+
+### Step 2: Add defensive guard in `src/hooks/atlas/idle-event.ts`
+- Before passing `boulderState.worktree_path` to `injectContinuation`, validate it's a string
+- Apply same guard in the `scheduleRetry` callback (line 86)
+- Ensures even if `readBoulderState` is bypassed, the idle handler won't crash
+
+### Step 3: Add test coverage in `src/hooks/atlas/index.test.ts`
+- Add test: boulder.json without `worktree_path` field → session.idle works
+- Add test: boulder.json with `worktree_path: null` → session.idle works (no `[Worktree: null]` in prompt)
+- Add test: `readBoulderState` sanitizes `null` worktree_path to `undefined`
+- Follow existing given/when/then test pattern
+
+### Step 4: Local validation
+```bash
+bun run typecheck
+bun test src/hooks/atlas/
+bun test src/features/boulder-state/
+bun run build
+```
+
+### Step 5: Atomic commit
+```bash
+git add src/features/boulder-state/storage.ts src/hooks/atlas/idle-event.ts src/hooks/atlas/index.test.ts
+git commit -m "fix(atlas): prevent crash when boulder.json missing worktree_path field
+
+readBoulderState() performs unsafe cast of parsed JSON as BoulderState.
+When worktree_path is absent or null in boulder.json, downstream code
+in idle-event.ts could receive null where string|undefined is expected.
+
+- Sanitize worktree_path in readBoulderState (reject non-string values)
+- Add defensive typeof check in idle-event before passing to continuation
+- Add test coverage for missing and null worktree_path scenarios"
+```
+
+## Phase 2: PR Creation
+
+```bash
+git push -u origin fix/atlas-worktree-path-crash
+gh pr create \
+  --base dev \
+  --title "fix(atlas): prevent crash when boulder.json missing worktree_path" \
+  --body-file /tmp/pull-request-atlas-worktree-fix.md
+```
+
+## Phase 3: Verify Loop
+
+- **Gate A (CI)**: `gh pr checks --watch` — wait for all checks green
+- **Gate B (review-work)**: Run 5-agent review (Oracle goal, Oracle quality, Oracle security, QA execution, context mining)
+- **Gate C (Cubic)**: Wait for cubic-dev-ai[bot] to respond "No issues found"
+- On any failure: fix-commit-push, re-enter verify loop
+
+## Phase 4: Merge
+
+```bash
+gh pr merge --squash --delete-branch
+git worktree remove ../omo-wt/fix-atlas-worktree-path-crash
+```

package/.agents/skills/work-with-pr-workspace/iteration-1/eval-2/with_skill/outputs/pr-description.md

@@ -0,0 +1,42 @@
+# PR Title
+
+```
+fix(atlas): prevent crash when boulder.json missing worktree_path
+```
+
+# PR Body
+
+## Summary
+
+- Fix runtime type violation in atlas hook when `boulder.json` lacks `worktree_path` field
+- Add `worktree_path` sanitization in `readBoulderState()` to reject non-string values (e.g., `null` from manual edits)
+- Add defensive `typeof` guards in `idle-event.ts` before passing worktree path to continuation injection
+- Add test coverage for missing and null `worktree_path` scenarios
+
+## Problem
+
+`readBoulderState()` in `src/features/boulder-state/storage.ts` casts raw `JSON.parse()` output directly as `BoulderState` via `return parsed as BoulderState`. This bypasses TypeScript's type system entirely at runtime.
+
+When `boulder.json` is missing the `worktree_path` field (common for boulders created before worktree support was added, or created without `--worktree` flag), `boulderState.worktree_path` is `undefined` which is handled correctly. However, when boulder.json has `"worktree_path": null` (possible from manual edits, external tooling, or corrupted state), the runtime type becomes `null` which violates the TypeScript type `string | undefined`.
+
+This `null` value propagates through:
+1. `idle-event.ts:handleAtlasSessionIdle()` → `injectContinuation()` → `injectBoulderContinuation()`
+2. `idle-event.ts:scheduleRetry()` callback → same chain
+
+While the `boulder-continuation-injector.ts` handles falsy values via `worktreePath ? ... : ""`, the type mismatch can cause subtle downstream issues and violates the contract of the `BoulderState` interface.
+
+## Changes
+
+| File | Change |
+|------|--------|
+| `src/features/boulder-state/storage.ts` | Sanitize `worktree_path` in `readBoulderState()` — reject non-string values |
+| `src/hooks/atlas/idle-event.ts` | Add `typeof` guards before passing worktree_path to continuation (2 call sites) |
+| `src/hooks/atlas/index.test.ts` | Add 2 tests: missing worktree_path + null worktree_path in session.idle |
+| `src/features/boulder-state/storage.test.ts` | Add 2 tests: sanitization of null + preservation of valid string |
+
+## Testing
+
+- `bun test src/hooks/atlas/` — all existing + new tests pass
+- `bun test src/features/boulder-state/` — all existing + new tests pass
+- `bun run typecheck` — clean
+- `bun run build` — clean

package/.agents/skills/work-with-pr-workspace/iteration-1/eval-2/with_skill/outputs/verification-strategy.md

@@ -0,0 +1,87 @@
+# Verification Strategy
+
+## Gate A: CI (`gh pr checks --watch`)
+
+### What CI runs (from `ci.yml`)
+1. **Tests (split)**: Mock-heavy tests in isolation + batch tests
+2. **Typecheck**: `bun run typecheck` (tsc --noEmit)
+3. **Build**: `bun run build` (ESM + declarations + schema)
+
+### Pre-push local validation
+Before pushing, run the exact CI steps locally to catch failures early:
+
+```bash
+# Targeted test runs first (fast feedback)
+bun test src/features/boulder-state/storage.test.ts
+bun test src/hooks/atlas/index.test.ts
+
+# Full test suite
+bun test
+
+# Type check
+bun run typecheck
+
+# Build
+bun run build
+```
+
+### Failure handling
+- **Test failure**: Read test output, fix code, create new commit (never amend pushed commits), push
+- **Typecheck failure**: Run `lsp_diagnostics` on changed files, fix type errors, commit, push
+- **Build failure**: Check build output for missing exports or circular deps, fix, commit, push
+
+After each fix-commit-push: `gh pr checks --watch` to re-enter gate
+
+## Gate B: review-work (5-agent review)
+
+### The 5 parallel agents
+1. **Oracle (goal/constraint verification)**: Checks the fix matches the stated problem — `worktree_path` crash resolved, no scope creep
+2. **Oracle (code quality)**: Validates code follows existing patterns — factory pattern, given/when/then tests, < 200 LOC, no catch-all files
+3. **Oracle (security)**: Ensures no new security issues — JSON parse injection, path traversal in worktree_path
+4. **QA agent (hands-on execution)**: Actually runs the tests, checks `lsp_diagnostics` on changed files, verifies the fix in action
+5. **Context mining agent**: Checks GitHub issues, git history, related PRs for context alignment
+
+### Expected focus areas for this PR
+- Oracle (goal): Does the sanitization in `readBoulderState` actually prevent the crash? Is the `typeof` guard necessary or redundant?
+- Oracle (quality): Are the new tests following the given/when/then pattern? Do they use the same mock setup as existing tests?
+- Oracle (security): Is the `worktree_path` value ever used in path operations without sanitization? (Answer: no, it's only used in template strings)
+- QA: Run `bun test src/hooks/atlas/index.test.ts` — does the null worktree_path test actually trigger the bug before fix?
+
+### Failure handling
+- Each oracle produces a PASS/FAIL verdict with specific issues
+- On FAIL: read the specific issue, fix in the worktree, commit, push, re-run review-work
+- All 5 agents must PASS
+
+## Gate C: Cubic (`cubic-dev-ai[bot]`)
+
+### What Cubic checks
+- Automated code review bot that analyzes the PR diff
+- Looks for: type safety issues, missing error handling, test coverage gaps, anti-patterns
+
+### Expected result
+- "No issues found" for this small, focused fix
+- 3 files changed (storage.ts, idle-event.ts, index.test.ts) + 1 test file
+
+### Failure handling
+- If Cubic flags an issue: evaluate if it's a real concern or false positive
+- Real concern: fix, commit, push
+- False positive: comment explaining why the flagged pattern is intentional
+- Wait for Cubic to re-review after push
+
+## Post-verification: Merge
+
+Once all 3 gates pass:
+```bash
+gh pr merge --squash --delete-branch
+git worktree remove ../omo-wt/fix-atlas-worktree-path-crash
+```
+
+On merge failure (conflicts):
+```bash
+cd ../omo-wt/fix-atlas-worktree-path-crash
+git fetch origin dev
+git rebase origin/dev
+# Resolve conflicts if any
+git push --force-with-lease
+# Re-enter verify loop from Gate A
+```

package/.agents/skills/work-with-pr-workspace/iteration-1/eval-2/with_skill/timing.json

@@ -0,0 +1 @@
+{"total_tokens": null, "duration_ms": 506000, "total_duration_seconds": 506}

package/.agents/skills/work-with-pr-workspace/iteration-1/eval-2/without_skill/grading.json

@@ -0,0 +1,11 @@
+{
+  "run_id": "eval-2-without_skill",
+  "expectations": [
+    {"text": "Plan uses git worktree in a sibling directory", "passed": false, "evidence": "No worktree. Steps go directly to creating branch and modifying files."},
+    {"text": "Fix is minimal — adds null check, doesn't refactor unrelated code", "passed": true, "evidence": "Focused fix though also adds try/catch in setTimeout (reasonable secondary fix)"},
+    {"text": "Test case added for the missing worktree_path scenario", "passed": true, "evidence": "Detailed test plan for missing/null/malformed boulder.json"},
+    {"text": "Verification loop includes all 3 gates", "passed": false, "evidence": "Only mentions CI pipeline (step 5). No review-work or Cubic."},
+    {"text": "References actual atlas hook files", "passed": true, "evidence": "References idle-event.ts, storage.ts with line numbers"},
+    {"text": "Branch name follows fix/ prefix convention", "passed": true, "evidence": "fix/atlas-hook-missing-worktree-path"}
+  ]
+}