@c-d-cc/reap 0.16.6 → 0.17.0

package/dist/templates/agents/reap-evaluate.md

@@ -152,6 +152,27 @@ You evaluate the evolve agent's work, not your own. If asked to assess your own
    - Pattern consistency with existing codebase
    - No unintended side effects
 4. Verify artifact completeness (all stages filled, no placeholders)
+5. **Impact analysis via daemon (when `config.daemon: true`)** — for each
+   changed file in the diff, query the daemon's impact endpoint to
+   surface dependent files the builder may not have re-validated:
+
+   ```bash
+   curl -sf http://127.0.0.1:17224/health || exit 0   # skip if down
+   PROJECT_ID=$(curl -s http://127.0.0.1:17224/projects \
+     | jq -r --arg p "$PWD" '.data[] | select(.path==$p) | .id')
+   git diff --name-only HEAD~1..HEAD | while read f; do
+     curl -s "http://127.0.0.1:17224/projects/$PROJECT_ID/impact?file=$f"
+   done
+   ```
+
+   Cross-reference the daemon's `directFiles` / `indirectFiles` against
+   the validation artifact's test coverage. If indirect-impacted files
+   were not exercised by the test run, surface this as a concern.
+   Index staleness: check `lastIndexedCommit` from
+   `/projects/$PROJECT_ID/status` against `git rev-parse HEAD` —
+   trigger a re-index (`POST /projects/$PROJECT_ID/index`) if they
+   differ before relying on impact output. Daemon-down or
+   daemon-opted-out projects skip this step silently.
 
 ### Phase 3: Fitness Assessment
 

package/dist/templates/agents/reap-evolve.md

@@ -74,3 +74,52 @@ When REAP creates any file (artifacts, backlog, etc.) with template sections (`<
 - Do NOT create backlog during adapt phase.
 - Do NOT return to the parent agent before generation completion — handle user interactions within this session.
 - tests/ is a git submodule — commit inside submodule first if modified.
+
+## Code Intelligence (Daemon) — opt-in
+
+REAP optionally integrates with a local code-intelligence daemon
+(`localhost:17224`) that maintains a Tree-sitter symbol graph for the
+project. When `config.daemon: true` is set, REAP auto-indexes at key
+lifecycle moments (start, learning, implementation complete, completion
+commit) and the daemon protocol section appears in your subagent prompt
+and the SessionStart context. Use it to make exploration and impact
+analysis faster.
+
+### When to use the daemon
+
+- **Learning stage** — find existing implementations by name before
+  reading source. Symbol search (`GET /projects/{id}/symbols?q=`)
+  returns file:line positions you can `Read` directly. Faster than
+  Grep for symbol-shaped queries (function/class/type names).
+- **Implementation stage** — before editing a function, query its
+  callers (`GET /projects/{id}/symbols/{id}/callers`) to understand
+  the change's blast radius. Helps avoid breaking out-of-sight call
+  sites.
+- **Validation stage** — for each changed file in your diff, query
+  `GET /projects/{id}/impact?file=<path>` to enumerate dependent
+  files. Cross-reference with your validation evidence.
+
+### Protocol
+
+Always probe first — daemon may be down or the user may not have
+opted in:
+
+```bash
+curl -sf http://127.0.0.1:17224/health || true   # silent skip if down
+```
+
+If healthy, look up the current project's ID once, then reuse it:
+
+```bash
+PROJECT_ID=$(curl -s http://127.0.0.1:17224/projects \
+  | jq -r --arg p "$PWD" '.data[] | select(.path==$p) | .id')
+```
+
+See `~/.reap/reap-guide.md` § Code Intelligence (Daemon) for the full
+query reference and staleness check protocol.
+
+### Fallback behaviour
+
+- Daemon down or `config.daemon !== true` → continue with normal
+  Read/Grep/Glob tools. The daemon is an accelerator, not a
+  requirement. Never block the lifecycle on a daemon problem.

package/dist/templates/reap-guide.md

@@ -302,6 +302,84 @@ All REAP interactions go through `/reap.*` slash commands. These are the primary
 - `reap cruise <count>` — Set cruise mode (pre-approve N generations for autonomous execution)
 - `reap update` — Update project structure to match current REAP version (v0.15 migrate, v0.16 sync)
 - `reap dump-state [--stdout] [--silent]` — Dump dynamic REAP context to `.reap/.session-state.md` (used by OpenCode plugin; useful for any external tool that needs current generation state)
+- `reap daemon status|stop|index|query` — Inspect or control the local code-intelligence daemon (see § Code Intelligence below)
+
+## Code Intelligence (Daemon)
+
+REAP ships with a local code-intelligence daemon (`@c-d-cc/reap-daemon`) that runs on `localhost:17224`. It maintains a Tree-sitter–backed symbol graph (functions, classes, types, calls, imports) persisted to SQLite, supports incremental updates, and exposes a small HTTP API for symbol search, caller/callee lookup, and change-impact analysis.
+
+### Opt-in
+
+Daemon integration is opt-in via `.reap/config.yml`:
+
+```yaml
+daemon: true
+```
+
+When opted in, REAP lifecycle commands (`start`, `learning`, `implementation complete`, `completion commit`) automatically register the project and trigger indexing. When omitted or `false`, daemon-related CLI behaviour is a no-op — byte-identical to projects that have never enabled it.
+
+### Auto-trigger points
+
+| Lifecycle moment | What runs |
+|---|---|
+| `reap run start` (generation created) | `ensureRegistered` + full `triggerIndexing` |
+| `reap run learning` (work phase) | `ensureRegistered` + `triggerIndexing` (keeps graph fresh before exploration) |
+| `reap run implementation` (complete phase) | `triggerIndexing` (so validation/evaluator see the just-written code) |
+| `reap run completion` (commit phase, post-archive) | `triggerIndexing` (graph reflects the committed state for the next generation) |
+
+All four call sites silent-fail when the daemon process is unreachable. The CLI lifecycle is never blocked by a daemon problem.
+
+### Querying the daemon
+
+Always verify the daemon is alive before querying — otherwise skip silently:
+
+```bash
+curl -sf http://127.0.0.1:17224/health || echo "daemon down"
+```
+
+Look up the current project's ID (set `CWD` to your project path):
+
+```bash
+PROJECT_ID=$(curl -s http://127.0.0.1:17224/projects \
+  | jq -r --arg p "$CWD" '.data[] | select(.path==$p) | .id')
+```
+
+Common queries:
+
+```bash
+# Symbol search by name (function, class, type, etc.)
+curl -s "http://127.0.0.1:17224/projects/$PROJECT_ID/symbols?q=consumeBacklog"
+
+# Callers of a specific symbol
+curl -s "http://127.0.0.1:17224/projects/$PROJECT_ID/symbols/<symbol-id>/callers"
+
+# Callees of a specific symbol
+curl -s "http://127.0.0.1:17224/projects/$PROJECT_ID/symbols/<symbol-id>/callees"
+
+# Impact (blast radius) of a file change
+curl -s "http://127.0.0.1:17224/projects/$PROJECT_ID/impact?file=src/core/lifecycle.ts"
+
+# Project status — includes lastIndexedAt and lastIndexedCommit (gen-068)
+curl -s "http://127.0.0.1:17224/projects/$PROJECT_ID/status"
+```
+
+### Index staleness
+
+`/projects/:id/status` returns `lastIndexedCommit` — the `git rev-parse HEAD` at the moment of the most recent successful indexing. To check whether the index is stale before a query:
+
+```bash
+INDEXED=$(curl -s "http://127.0.0.1:17224/projects/$PROJECT_ID/status" | jq -r '.data.lastIndexedCommit // "none"')
+HEAD=$(git rev-parse HEAD)
+[ "$INDEXED" = "$HEAD" ] && echo "fresh" || echo "stale — trigger reindex"
+```
+
+If stale, you can request a re-index with `curl -X POST "http://127.0.0.1:17224/projects/$PROJECT_ID/index"`. The lifecycle auto-triggers above usually keep the index fresh; manual re-index is only needed for between-stage tweaks or out-of-band edits.
+
+### When to use daemon vs filesystem search
+
+- **Daemon-first**: symbol definition lookup, caller/callee traversal, multi-file impact analysis.
+- **Filesystem-first (Grep/Glob)**: literal string search, comment search, files with no parser support, daemon down.
+- The two are complementary — symbol-graph queries return file:line positions you can `Read` immediately.
 
 ## AI Client Support
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@c-d-cc/reap",
-  "version": "0.16.6",
+  "version": "0.17.0",
   "description": "Recursive Evolutionary Autonomous Pipeline — AI and humans evolve software across generations",
   "license": "MIT",
   "author": "HyeonIL Choi <hichoi@c-d.cc> (C to D)",