forge-server 0.1.0

package/docs/plans/completed/2026-02-27-forge-swarm-learning/architecture.md

@@ -0,0 +1,480 @@
+> **Status**: COMPLETE (2026-02-27). All 5 phases implemented. 12 new MCP tools added (22 -> 34), 5-signal scoring, auto-observations on all submit_* handlers, confidence tracking with decay, git history enrichment, Atlassian integration, VS Code extension, all 12 agent prompts updated. Executed via 10 parallel agents using `general-purpose` type (worktree isolation bypassed due to Windows detection bug). Archived to `docs/plans/completed/` on 2026-02-27.
+
+# Plan: Forge 2-Way Query Engine — Swarm Learning Architecture
+
+## Context
+
+The forge pipeline server was built from the Graph RAG vision to replace vexp. The vector search, graph layer, AST parsing, hybrid scoring, and knowledge system are all implemented. But **most of the internal machinery is not exposed as MCP tools**:
+
+- `QUERY_INBOUND_IMPACT` / `QUERY_OUTBOUND_IMPACT` Cypher queries exist in `graph-queries.ts` — **no MCP tool**
+- `QUERY_SHORTEST_PATH` Cypher query exists — **no MCP tool**
+- `observation-store.ts` has full `saveObservation()` with symbol linking — **no MCP tool**
+- `session-tracker.ts` has `getRecentSessionObservations()`, `getSessionInfo()` — **no MCP tool**
+- `confidence.ts` has `ConfidenceManager.boost()` and `decayAll()` — **never called**
+- `intent-detector.ts` has `detectIntent()` + `getIntentStrategy()` — **bypassed** (hardcoded `'read'` at `context-tools.ts:131`)
+- `MemoryBridge` has `saveMemory()` + `searchMemories()` — **only used in interview context injection**
+
+The result is that forge has 22 MCP tools but agents can't access impact graphs, logic flows, session memory, or observation persistence. The knowledge confidence system exists but is inert. The intent detector exists but is bypassed.
+
+**Goal**: Wire up all internal capabilities as MCP tools, add auto-observation during pipeline execution, activate confidence tracking, implement git history enrichment, and update all 12 agent prompts. Transform forge into a bidirectional query engine where agents pull context (Way 1) and push learnings back (Way 2).
+
+---
+
+## Phase 1: vexp Feature Parity — Expose Internal Code as MCP Tools
+
+**Value**: Agents gain impact graphs, logic flows, session memory, and intent-aware search. Zero new algorithms needed — this is pure wiring.
+
+### 1.1 Create `src/tools/memory-tools.ts` (NEW)
+
+Three tools following the pattern in `context-tools.ts`:
+
+**`save_observation`** — wraps `saveObservation()` from `src/memory/observation-store.ts:56`
+- Schema: `{ content, symbols?[], repo_id?, importance?, tags?[], category?, type? }`
+- Handler: calls `saveObservation()` with `getCurrentSessionId()` from `session-tracker.ts:32`
+- Returns: `{ id, stored, linkedSymbols, unresolvedSymbols }`
+
+**`search_memory`** — wraps `MemoryBridge.searchMemories()` from `src/context/memory.ts:46`
+- Schema: `{ query, repo_id?, session_id?, limit?, score_threshold? }`
+- Returns: `{ results: [{ content, created_at, relevance_score, session_id }] }`
+
+**`get_session_context`** — wraps `getRecentSessionObservations()` from `src/memory/session-tracker.ts:177`
+- Schema: `{ query?, session_count?, limit? }`
+- Returns: `{ current_session: {...}, recent_sessions: [...groups] }`
+- Also calls `persistSessionMarker()` (line 83) to ensure current session is discoverable
+
+### 1.2 Create `src/tools/graph-tools.ts` (NEW)
+
+Two tools:
+
+**`get_impact_graph`** — wraps `QUERY_INBOUND_IMPACT` / `QUERY_OUTBOUND_IMPACT` from `src/query/graph-queries.ts:66-81`
+- Schema: `{ symbol, repo_id, direction: 'inbound'|'outbound'|'both', depth? }`
+- Handler: executes appropriate Cypher via `graphStore.query()`, parses raw FalkorDB response
+- Returns: `{ symbol, direction, nodes: [...], edges: [...], total_nodes, total_edges }`
+- Graceful degradation: returns `{ error: 'GRAPH_UNAVAILABLE' }` when FalkorDB is down
+
+**`search_logic_flow`** — wraps `QUERY_SHORTEST_PATH` from `src/query/graph-queries.ts:90-96`
+- Schema: `{ from_symbol, to_symbol, repo_id, max_depth? }`
+- Returns: `{ from_symbol, to_symbol, paths: [...], connected: boolean }`
+
+### 1.3 Wire intent detection into `get_codebase_context`
+
+**Modify**: `src/tools/context-tools.ts`
+- Import `detectIntent`, `getIntentStrategy` from `src/query/intent-detector.ts`
+- Call `detectIntent(input.query)` to classify query
+- Call `getIntentStrategy(intent)` to get weight adjustments
+- Pass weights through to `codebaseContext.getContext()` (requires adding fields to `CodebaseContextOptions`)
+- Return actual detected `query_intent` instead of hardcoded `'read'`
+- Also populate `related_memories` by calling `memoryBridge.searchMemories()` (currently returns `[]` at line 130)
+
+**Modify**: `src/context/codebase.ts` — Add to `CodebaseContextOptions` (line 28):
+```typescript
+vectorWeight?: number;   // from intent strategy, default 0.6
+graphWeight?: number;    // from intent strategy, default 0.3
+recencyWeight?: number;  // from intent strategy, default 0.1
+expandDepth?: number;    // from intent strategy, default 2
+```
+In `getContext()` at line 76, destructure these from options and pass to `hybridSearch()` call at line 127-135:
+```typescript
+const searchResults = await hybridSearch(this.vectorStore, effectiveGraph, {
+  query,
+  repoId,
+  limit: maxResults * 2,
+  includeTests: options.includeTests ?? includeTests, // intent strategy can override
+  vectorWeight: options.vectorWeight,
+  graphWeight: options.graphWeight,
+});
+```
+Note: `hybridSearch` already accepts `vectorWeight` and `graphWeight` in `HybridSearchOptions` (hybrid-search.ts:24-25).
+
+### 1.4 Add `get_index_status` to `src/tools/registration-tools.ts`
+
+- Schema: `{ repo_id? }`
+- Consolidates: `vectorStore.getCounts()`, `graphStore.getCounts()`, `fileCache.getStats()`, `getUptimeSeconds()` from session-tracker, health status for each backend
+- Returns: `{ repos, qdrant_health, falkordb_health, uptime_seconds, embedding_model, cache_stats }`
+
+### 1.5 Wire into `src/server.ts`
+
+- Import `createMemoryTools` and `createGraphTools`
+- Create factories: `createMemoryTools(memoryBridge, vectorStore, graphStore)`, `createGraphTools(graphStore)`
+- Spread into `allTools`
+- Pass `memoryBridge` to `createContextTools()` (for `related_memories` in `get_codebase_context`)
+
+### Phase 1 Files
+
+| File | Action |
+|------|--------|
+| `src/tools/memory-tools.ts` | CREATE |
+| `src/tools/graph-tools.ts` | CREATE |
+| `src/tools/context-tools.ts` | MODIFY — intent detection + related_memories |
+| `src/tools/registration-tools.ts` | MODIFY — add get_index_status |
+| `src/context/codebase.ts` | MODIFY — accept weight overrides in options, pass to hybridSearch |
+| `src/server.ts` | MODIFY — wire new tool factories |
+
+**Tool count: 22 → 28** (+6: save_observation, search_memory, get_session_context, get_impact_graph, search_logic_flow, get_index_status)
+
+---
+
+## Phase 2: Swarm Learning — Auto-Observations + Confidence Tracking
+
+**Value**: Agents automatically push learnings during pipeline execution. Knowledge items that prove useful gain confidence; unused ones decay. The system gets smarter over time.
+
+### 2.1 Auto-observations in phase handlers
+
+**Modify**: `src/tools/phase-tools.ts`
+
+In each `submit_*` handler, after successfully storing the phase output in SQLite, fire-and-forget call to `saveObservation()`:
+- `submit_vision`: save summary of vision (first 500 chars), `type: 'procedural'`, `category: 'vision'`, `importance: 0.6`
+- `submit_plan`: save architecture summary, `category: 'architecture'`, `importance: 0.6`
+- `submit_design`: save design summary, `category: 'design'`, `importance: 0.5`
+- `submit_test_plan`: save test plan summary, `category: 'test_plan'`, `importance: 0.5`
+- `submit_implementation`: save module completion summary, `category: 'implementation'`, `importance: 0.5`
+- `submit_verdict`: save verdict + findings summary, `category: 'inspection'`, `importance: 0.7`
+- All tagged with `['auto_observation', phase_name, project_id]`
+- All wrapped in try/catch, logged on failure, **never block** the phase transition
+
+Needs: import `saveObservation` from `observation-store.ts`, `getCurrentSessionId` from `session-tracker.ts`, and access to `vectorStore` + `graphStore` (pass through `createPhaseTools` factory as `createPhaseTools(engine, contextInjector, vectorStore, graphStore)`).
+
+**CRITICAL**: Guard against `vectorStore === null` and `graphStore === null`. When either backend is unavailable, skip auto-observation silently (log at debug level, never throw).
+
+### 2.2 Staleness detection on re-index
+
+**Modify**: `src/ingestion/indexer.ts`
+
+When a file is re-indexed and entities have changed (AST diff between old and new), call `MARK_SYMBOL_OBSERVATIONS_STALE` from `graph-queries.ts:170` for each changed symbol. This invalidates observations that reference modified code.
+
+### 2.3 Wire confidence tracking
+
+**Modify**: `src/context/injector.ts`
+- Accept `ConfidenceManager` (from `src/learning/confidence.ts`) + `QdrantVectorStore` in constructor
+- After each `knowledgeSearch.search*()` call that returns results, fire-and-forget `confidenceManager.boost()` for each result ID
+- This means knowledge items actually used by agents see confidence rise automatically
+
+**Modify**: `src/server.ts`
+- Instantiate `ConfidenceManager`
+- Pass to `ContextInjector` constructor
+- Add periodic decay: `setInterval(() => confidenceManager.decayAll(vectorStore), 24 * 60 * 60 * 1000)` (daily)
+
+### 2.4 Add `boost_knowledge` and `decay_knowledge` MCP tools
+
+**Modify**: `src/tools/learning-tools.ts`
+
+**`boost_knowledge`**: `{ knowledge_id, amount?, reason? }` — calls `confidenceManager.boost()`
+**`decay_knowledge`**: `{ decay_rate? }` — calls `confidenceManager.decayAll()`
+
+For Knowledge Keeper agent to use explicitly when it identifies valuable or outdated knowledge.
+
+### Phase 2 Files
+
+| File | Action |
+|------|--------|
+| `src/tools/phase-tools.ts` | MODIFY — auto-observation on each submit |
+| `src/ingestion/indexer.ts` | MODIFY — mark stale observations on re-index |
+| `src/context/injector.ts` | MODIFY — auto-boost on knowledge injection |
+| `src/tools/learning-tools.ts` | MODIFY — add boost_knowledge, decay_knowledge |
+| `src/server.ts` | MODIFY — wire ConfidenceManager, periodic decay |
+
+**Tool count: 28 → 30** (+2: boost_knowledge, decay_knowledge)
+
+---
+
+## Phase 3: Git History Enrichment
+
+**Value**: 4th scoring signal (hotspot), commit message search, file stability metrics. Implements git-jira-plan.md Part 1.
+
+### 3.1 Types
+
+**Modify**: `src/util/types.ts`
+- Add `FileChangeStats`: `{ commitCount, stabilityScore, changeVelocity, lastCommitHash, lastCommitTs, recentMessages[] }`
+- Add `CommitRecord`: `{ hash, message, author, timestamp, files[] }`
+- Add `GitCommitPayload` for Qdrant: `{ repo_id, commit_hash, message, author, timestamp, file_paths[] }`
+
+### 3.2 Enrich git analyzer
+
+**Modify**: `src/ingestion/git-analyzer.ts`
+- Add a SECOND `git log` call (do NOT modify the existing one used for co-modification parsing). New format: `git log --format="%H|%s|%an|%aI" --name-only` for subject, author, date
+- Add `analyzeFileStats()` — per-file commit count, stability score (0-1), change velocity (-1 to +1)
+- Add `extractCommitRecords()` — parse into `CommitRecord[]`, filter merge commits + bulk reformats (>50 files)
+- Return `EnrichedGitAnalysisResult` extending `GitAnalysisResult` with `fileStats: Map<string, FileChangeStats>` and `commits: CommitRecord[]`
+
+### 3.3 Qdrant git_commits collection
+
+**Modify**: `src/storage/qdrant-store.ts`
+- Add `ensureGitCommitsCollection()` in `ensureCollections()`
+- Add `upsertGitCommits()`, `searchGitCommits()`, `deleteGitCommitsByRepo()` as **QdrantVectorStore-specific methods** (NOT on the `VectorStore` interface — follows existing pattern at indexer.ts:484 where concrete type is used via cast)
+
+### 3.3b Write `commit_count` to FalkorDB File nodes
+
+**Modify**: `src/ingestion/indexer.ts`
+- After `runGitAnalysis()` returns `EnrichedGitAnalysisResult`, iterate `fileStats` map
+- For each file with stats, call `graphStore.upsertNode('File', { path, repo_id }, { commit_count, stability_score, change_velocity, last_commit_hash, last_commit_ts })` to write git properties onto existing File nodes
+- This provides the data source for Phase 3.5's hotspot scoring
+
+### 3.4 4-signal ranking
+
+**Modify**: `src/query/ranking.ts`
+- Weights: `0.55 vector + 0.25 graph + 0.10 recency + 0.10 hotspot`
+- Add `hotspotScore` and `hotspotWeight` to `computeScore()` (backward-compatible: defaults to 0/0.10)
+- Add `hotspotScore` to `ScoredResult`
+
+### 3.5 Hybrid search hotspot integration
+
+**Modify**: `src/query/hybrid-search.ts`
+- After graph expansion, fetch file hotspot scores from FalkorDB File node `commit_count` property
+- Normalize: `hotspot = file.commit_count / max_commit_count_in_results`
+- For `modify`/`debug`/`refactor` intent: pass hotspot. For `read` intent: pass 0
+
+### 3.6 New graph queries
+
+**Modify**: `src/query/graph-queries.ts`
+- Add `QUERY_FILE_HOTSPOTS(repoId)` — top 100 files by commit_count
+- Add `QUERY_FILE_STATS(filePath, repoId)` — single file stats
+
+### 3.7 `get_git_context` MCP tool
+
+**Modify**: `src/tools/context-tools.ts`
+- Modes: `hotspots` | `commit_search` | `file_history`
+- `hotspots`: top N files by change frequency + stability + velocity from FalkorDB
+- `commit_search`: semantic search over commit messages in Qdrant `git_commits`
+- `file_history`: last N commits for a specific file
+
+### Phase 3 Files
+
+| File | Action |
+|------|--------|
+| `src/util/types.ts` | MODIFY |
+| `src/ingestion/git-analyzer.ts` | MODIFY |
+| `src/ingestion/indexer.ts` | MODIFY — embed commit messages |
+| `src/storage/qdrant-store.ts` | MODIFY — git_commits collection |
+| `src/query/ranking.ts` | MODIFY — 4-signal scoring |
+| `src/query/hybrid-search.ts` | MODIFY — hotspot integration |
+| `src/query/graph-queries.ts` | MODIFY — hotspot queries |
+| `src/tools/context-tools.ts` | MODIFY — get_git_context tool |
+| `src/server.ts` | MODIFY — wire new tool |
+
+**Tool count: 30 → 31** (+1: get_git_context)
+
+---
+
+## Phase 4: 5-Signal Scoring + LSP Edge Ingestion + VS Code Extension
+
+**Value**: Observation relevance becomes the 5th scoring signal. LSP edges enrich the graph beyond static parsing. A VS Code extension automatically feeds type-resolved call edges into forge.
+
+### 4.1 5-signal scoring
+
+**Modify**: `src/query/ranking.ts`
+- Weights become intent-dependent:
+
+| Intent | Vector | Graph | Recency | Hotspot | Observation |
+|--------|--------|-------|---------|---------|-------------|
+| read | 0.55 | 0.20 | 0.05 | 0.10 | 0.10 |
+| modify | 0.50 | 0.20 | 0.08 | 0.12 | 0.10 |
+| debug | 0.40 | 0.25 | 0.05 | 0.10 | 0.20 |
+| refactor | 0.35 | 0.30 | 0.05 | 0.15 | 0.15 |
+
+- Add `observationScore: number` to `ScoredResult` interface and `observationWeight: number` to `computeScore()` params
+- Observation score = count of non-stale observations linked to file symbols, normalized by max in result set
+- Query Qdrant observations collection per file in results (parallelized with graph expansion, ~1-5ms each on localhost)
+
+### 4.2 `submit_lsp_edges` MCP tool
+
+**Create**: `src/tools/ingestion-tools.ts`
+- Schema: `{ repo_id, edges: [{ from_file, from_symbol, to_file, to_symbol, edge_type }] }`
+- Handler: iterates edges, calls `graphStore.upsertEdge()` for each
+- Returns: `{ accepted, failed }`
+- Designed for the VS Code extension and CI pipelines
+
+### 4.3 VS Code Extension — `forge-lsp-bridge`
+
+**Create**: `vscode-extension/` directory at repo root (separate publishable extension)
+
+Minimal VS Code extension that hooks into TypeScript Language Server and sends call/reference edges to forge:
+
+- `vscode-extension/package.json` — extension manifest, activates on TS/JS files
+- `vscode-extension/src/extension.ts` — entry point, registers document change listener
+- `vscode-extension/src/edge-collector.ts` — on file save, queries TS language server for:
+  - Call hierarchy (`vscode.commands.executeCommand('vscode.prepareCallHierarchy')`)
+  - Type definitions and references
+  - Collects edges as `{ from_file, from_symbol, to_file, to_symbol, edge_type }`
+- `vscode-extension/src/forge-client.ts` — sends batched edges to forge MCP via stdio or HTTP
+  - Debounced: collects edges for 5 seconds after each save, then sends batch
+  - Config: `forge.lspBridge.enabled` (default: true), `forge.lspBridge.repoId` (auto-detected from .forge/manifest.yaml)
+- `vscode-extension/tsconfig.json`, `vscode-extension/.vscodeignore`
+
+**Key design**: The extension does NOT replace forge's static AST parsing — it supplements it with runtime-accurate type-resolved edges that tree-sitter misses (indirect calls, generics, overloaded methods).
+
+### Phase 4 Files
+
+| File | Action |
+|------|--------|
+| `src/query/ranking.ts` | MODIFY — 5-signal weights |
+| `src/query/hybrid-search.ts` | MODIFY — observation query |
+| `src/query/intent-detector.ts` | MODIFY — 5-weight strategy tables |
+| `src/tools/ingestion-tools.ts` | CREATE — submit_lsp_edges |
+| `src/server.ts` | MODIFY — wire ingestion tools |
+| `vscode-extension/` (entire directory) | CREATE — VS Code extension |
+
+**Tool count: 31 → 32** (+1: submit_lsp_edges)
+
+---
+
+## Phase 5: Agent Prompt Updates + Cross-Agent Collaboration
+
+**Value**: All 12 agents know about and use the new tools. Agent-to-agent broadcasting enables real-time knowledge sharing during pipeline execution.
+
+### 5.1 Update all 12 agent prompts
+
+Add "Memory & Observation Tools" + "Graph Analysis Tools" sections to each agent in `plugin/agents/`:
+
+**Agents that actively push observations** (produce learnings):
+- `architect.md` — save architectural decisions, blast radius findings
+- `inspector.md` — save findings, anti-patterns, verification results
+- `knowledge-keeper.md` — save curated knowledge, route to appropriate store
+- `backend-specialist.md`, `frontend-specialist.md`, `data-specialist.md`, `platform-engineer.md` — save implementation gotchas
+
+**Agents that actively pull observations** (consume context):
+- `strategist.md` — `search_memory` for similar past projects
+- `supervisor.md` — `get_session_context` for what's been learned so far
+- `architect.md` — `get_impact_graph` for blast radius, `search_logic_flow` for execution paths
+- `inspector.md` — `get_git_context` for hotspot-aware verification
+
+### 5.2 Agent broadcast primitive
+
+**Create**: `src/tools/collaboration-tools.ts`
+
+**`broadcast_finding`**: `{ project_id, content, severity: 'info'|'warning'|'critical', target_agents?[], symbols?[] }`
+- Saves as observation with `type: 'working'`, `category: 'agent_broadcast'`, `tags: ['broadcast', project_id]`
+- Also records in SQLite `pipeline_events` as `agent_broadcast` event type
+
+**`get_broadcasts`**: `{ project_id, since?, severity? }`
+- Queries recent broadcasts for the project
+
+**Modify**: `src/context/injector.ts` — include recent broadcasts when assembling phase context
+
+### 5.3 Atlassian Integration (from git-jira-plan.md Part 2)
+
+Plugin-level only — no server code changes.
+
+**Modify**: `plugin/.mcp.json` — add `atlassian` server:
+```json
+"atlassian": {
+  "command": "uvx",
+  "args": ["mcp-atlassian"],
+  "env": { "JIRA_URL": "${JIRA_URL}", "JIRA_USERNAME": "${JIRA_USERNAME}", "JIRA_API_TOKEN": "${JIRA_API_TOKEN}" }
+}
+```
+
+**Update 7 agent prompts** with optional Atlassian sections (graceful — skip if unavailable):
+- `strategist.md` — pull linked Jira issue, sprint context pre-interview; comment post-vision
+- `architect.md` — check blocking issues, linked PRs; comment post-plan
+- `inspector.md` — check acceptance criteria; comment pass/fail + transition issue
+- `knowledge-keeper.md` — pull ticket changelog for decision history
+- `product-manager.md` — pull existing stories/epics to avoid duplicate requirements
+- `supervisor.md` — check sprint capacity for routing priority
+- `platform-engineer.md` — CI pipeline status (future Bitbucket)
+
+**Create**: `plugin/docs/atlassian-integration.md` — setup guide
+
+**Graceful degradation**: Every Atlassian section wrapped in "## Atlassian Context (Optional)" with "If unavailable, skip without error."
+
+### 5.4 Extend `create_project` for Jira context
+
+**Modify**: `src/tools/pipeline-tools.ts`
+- Add optional `jira_ticket` and `jira_epic` fields to `createProjectSchema`
+- Store in project metadata JSON
+- Returned by `get_state` — agents auto-discover ticket key
+
+### Phase 5 Files
+
+| File | Action |
+|------|--------|
+| `plugin/agents/*.md` (12 files) | MODIFY — new tool sections + Atlassian |
+| `plugin/.mcp.json` | MODIFY — add atlassian server |
+| `plugin/docs/atlassian-integration.md` | CREATE — setup guide |
+| `src/tools/collaboration-tools.ts` | CREATE — broadcast_finding, get_broadcasts |
+| `src/tools/pipeline-tools.ts` | MODIFY — jira_ticket, jira_epic fields |
+| `src/context/injector.ts` | MODIFY — broadcast injection |
+| `src/util/types.ts` | MODIFY — add agent_broadcast event type |
+| `src/server.ts` | MODIFY — wire collaboration tools |
+
+**Tool count: 32 → 34** (+2: broadcast_finding, get_broadcasts)
+
+---
+
+## Phase Dependencies
+
+```
+Phase 1 (vexp parity) — no dependencies, all items parallelizable
+    |
+    v
+Phase 2 (swarm learning) — depends on Phase 1 (needs save_observation tool)
+    |
+    v
+Phase 3 (git enrichment) — independent of Phase 2, can run in parallel
+    |
+    +-----+-----+
+    |           |
+    v           v
+Phase 4      Phase 5
+(5-signal)   (agent prompts + collaboration)
+depends on   Phase 5 depends on Phase 1 (tools must exist before prompts reference them)
+Phase 2+3    Phase 5 Atlassian section is independent of all other phases
+```
+
+**Parallelism opportunities:**
+- Phase 1: all 4 new files are independent of each other
+- Phase 2 and Phase 3 can overlap (Phase 2 needs Phase 1 done; Phase 3 is independent)
+- Phase 5 agent prompts can start after Phase 1 (for graph/memory tools) and expand after later phases
+
+---
+
+## Existing Code to Reuse (NOT rebuild)
+
+| Capability | File:Line | Status |
+|-----------|-----------|--------|
+| `saveObservation()` | `src/memory/observation-store.ts:56` | Fully implemented, needs MCP wrapper |
+| `getRecentSessionObservations()` | `src/memory/session-tracker.ts:177` | Fully implemented, needs MCP wrapper |
+| `getCurrentSessionId()` | `src/memory/session-tracker.ts:32` | Working |
+| `persistSessionMarker()` | `src/memory/session-tracker.ts:83` | Working |
+| `getSessionInfo()` | `src/memory/session-tracker.ts:320` | Working |
+| `MemoryBridge.searchMemories()` | `src/context/memory.ts:46` | Working, used only in interview injection |
+| `MemoryBridge.saveMemory()` | `src/context/memory.ts:123` | Working, never called |
+| `QUERY_INBOUND_IMPACT` | `src/query/graph-queries.ts:66` | Working Cypher, no MCP tool |
+| `QUERY_OUTBOUND_IMPACT` | `src/query/graph-queries.ts:76` | Working Cypher, no MCP tool |
+| `QUERY_SHORTEST_PATH` | `src/query/graph-queries.ts:90` | Working Cypher, no MCP tool |
+| `UPSERT_OBSERVATION` | `src/query/graph-queries.ts:136` | Used by observation-store |
+| `LINK_OBSERVATION_TO_SYMBOL` | `src/query/graph-queries.ts:153` | Used by observation-store |
+| `MARK_SYMBOL_OBSERVATIONS_STALE` | `src/query/graph-queries.ts:170` | Exists, never called |
+| `detectIntent()` | `src/query/intent-detector.ts:39` | Working, never called from tools |
+| `getIntentStrategy()` | `src/query/intent-detector.ts:70` | Working, never called from tools |
+| `ConfidenceManager.boost()` | `src/learning/confidence.ts:147` | Fully implemented, never called |
+| `ConfidenceManager.decayAll()` | `src/learning/confidence.ts:66` | Fully implemented, never called |
+| `buildSkeleton()` | `src/context/codebase.ts:308` | Working |
+
+---
+
+## Verification
+
+### After Phase 1
+1. `npm run build` succeeds
+2. `npm test` passes
+3. Call `mcp__dk-forge__save_observation` with `{ content: "test observation", symbols: ["createForgeServer"], repo_id: "..." }` — returns `{ stored: true, linkedSymbols: [...] }`
+4. Call `mcp__dk-forge__search_memory` with `{ query: "test observation" }` — returns the saved observation
+5. Call `mcp__dk-forge__get_session_context` — returns current session info + recent observations
+6. Call `mcp__dk-forge__get_impact_graph` with `{ symbol: "createForgeServer", repo_id: "...", direction: "inbound" }` — returns callers
+7. Call `mcp__dk-forge__search_logic_flow` with two known connected symbols — returns path
+8. Call `mcp__dk-forge__get_codebase_context` with a debug-style query — verify `query_intent` is `'debug'` (not `'read'`)
+
+### After Phase 2
+9. Run a `/forge new test-project` through to `submit_verdict` — verify observations were auto-created (search for `tags: ['auto_observation']`)
+10. Verify `boostConfidence` is being called by checking logs for "ConfidenceManager.boost: boosted"
+11. Re-index a repo with a modified file — verify stale observations appear in search with `is_stale: true`
+
+### After Phase 3
+12. Call `mcp__dk-forge__get_git_context` with `mode: 'hotspots'` — returns files sorted by commit frequency
+13. Call `mcp__dk-forge__get_git_context` with `mode: 'commit_search', query: 'rebrand'` — returns relevant commits
+14. Call `mcp__dk-forge__get_codebase_context` — verify `match_reason` includes hotspot info for frequently-changed files
+
+### After All Phases
+15. Rebuild dist: `npm run build`
+16. Full pipeline run with `/forge new integration-test` — verify all agents can access new tools
+17. Verify tool count matches expected (34 total)