feat(ingestion): add ingestion API routes + integration tests

[fagemx]

Context

Track D Step 3 — HTTP API for ingestion evaluation, record listing, and suggestion management.

What Needs to Happen

• Routes:
  • POST /api/ingestion/evaluate → auto/suggest/skip
  • POST /api/ingestion/records → manual ingestion
  • GET /api/ingestion/records → list with filters
  • GET /api/ingestion/suggestions → list pending
  • POST /api/ingestion/suggestions/:id/accept
  • POST /api/ingestion/suggestions/:id/reject
• Integration tests: auto event → record, suggest → queue → accept → record, never → skip

Definition of Done

• cargo build zero errors
• All API routes respond correctly
• Full flow integration tests pass
• cargo test -p edda-ingestion all pass

References

• Plan: thyra/docs/plan/storage/TRACK_D_EDDA_INGESTION.md Step 3
• Blocked by: edda#327

---

Decomposed from docs/plan/storage by plan-decompose

[fagemx]

Blocked by edda#327.

[fagemx]

Research: Ingestion API Routes + Integration Tests (GH-328)

1. Issue Summary

Track D Step 3: expose the ingestion trigger engine and suggestion queue (built in GH-326 and GH-327) through HTTP API routes in edda-serve. Six routes total, plus integration tests covering the three ingestion flows (auto/suggest/skip).

Required Routes

POST   /api/ingestion/evaluate              -> auto/suggest/skip
POST   /api/ingestion/records               -> manual ingestion (bypass trigger)
GET    /api/ingestion/records               -> list ingestion records (with filters)
GET    /api/ingestion/suggestions           -> list pending suggestions
POST   /api/ingestion/suggestions/:id/accept
POST   /api/ingestion/suggestions/:id/reject

2. Existing Codebase Analysis

2.1 edda-ingestion crate (complete from GH-326 + GH-327)

Files: crates/edda-ingestion/src/{lib.rs, types.rs, trigger.rs, suggestion.rs, writer.rs}

Public API (from lib.rs re-exports):

• evaluate_trigger(event_type: &str, source_layer: &str) -> TriggerResult
• write_ingestion_record(ledger: &Ledger, record: &IngestionRecord) -> anyhow::Result<()>
• SuggestionQueue::new(ledger: &Ledger) with methods: enqueue(), list_pending(), accept(id), reject(id)
• Types: IngestionRecord, SourceLayer, SourceRef, Suggestion, SuggestionStatus, TriggerResult, TriggerType

Key details:

• IngestionRecord has camelCase serde (#[serde(rename_all = "camelCase")])
• Suggestion has camelCase serde
• TriggerType has snake_case serde (auto, suggested, manual)
• SuggestionStatus has snake_case serde (pending, accepted, rejected)
• SourceLayer serializes as "L0", "L1", etc.
• IngestionRecord::new_id(prefix) generates "prefix_{ulid}" format
• Suggestion::new_id() generates "sug_{ulid}" format
• write_ingestion_record() stores the record as an event with event_type = "ingestion" in the ledger
• SuggestionQueue::accept() writes an IngestionRecord with trigger_type = Suggested

2.2 edda-ledger layer

Suggestion storage (schema V12):

• SuggestionRow struct (all String fields, not typed enums)
• ledger.insert_suggestion(row) -- insert
• ledger.list_suggestions_by_status(status) -- filter by status string
• ledger.get_suggestion(id) -- lookup by id
• ledger.update_suggestion_status(id, status, reviewed_at) -- update status
• ledger.iter_events_by_type("ingestion") -- read back ingestion events

2.3 edda-serve crate patterns

File: crates/edda-serve/src/lib.rs (~7983 lines)

Architecture:

• Single lib.rs with all handlers (no module splitting yet)
• AppState holds repo_root: PathBuf + optional chronicle context
• AppError enum: Validation (400), NotFound (404), Conflict (409), Unauthorized (401), Internal (500)
• AppError has From<anyhow::Error>, From<serde_json::Error>, From<std::io::Error> impls

Route registration:

• Production routes in serve() function with auth middleware
• Test router: separate #[cfg(test)] fn router() duplicating all routes without auth middleware
• Both must be updated in lockstep

Handler signature patterns:

• GET with query: async fn handler(State(state), Query(params)) -> Result<Json<T>, AppError>
• POST with JSON: async fn handler(State(state), body: Result<Json<Body>, JsonRejection>) -> Result<impl IntoResponse, AppError>
• POST with path param: async fn handler(State(state), AxumPath(id): AxumPath<String>, body) -> Result<...>

Test pattern:

let tmp = tempfile::tempdir().unwrap();
setup_workspace(tmp.path());
let app = router(tmp.path());
let resp = app.oneshot(Request::builder()...).await.unwrap();

For multi-step tests, create new router(tmp.path()) for each request.

2.4 Dependency gap

edda-serve/Cargo.toml does NOT currently depend on edda-ingestion. Must add:

edda-ingestion = { path = "../edda-ingestion", version = "0.1.1" }

3. Key Design Considerations

3.1 POST /api/ingestion/evaluate flow

• Input: { event_type, source_layer } (minimum), plus optional source_refs, summary, detail, tags
• On AutoIngest: build IngestionRecord, call write_ingestion_record(), return { action: "ingested", recordId }
• On SuggestIngest: build Suggestion, call SuggestionQueue::enqueue(), return { action: "queued", suggestionId }
• On Skip: return { action: "skipped" } with 200 OK

3.2 Error mapping for suggestion actions

SuggestionQueue errors are anyhow strings. Need to map:

• "suggestion not found: {id}" -> AppError::NotFound (404)
• "suggestion {id} has status '{s}', expected 'pending'" -> AppError::Conflict (409)

Best approach: check for existence and status before calling queue methods (consistent with existing post_draft_approve pattern that checks status first).

3.3 Wire format consistency

All types already use camelCase serde. API responses should also use camelCase for field names.

3.4 Multi-step test strategy

For the suggest->accept flow test, re-create router between requests (same tempdir). This is the existing pattern throughout the codebase.

4. Impact Assessment

Files to modify:

1. crates/edda-serve/Cargo.toml -- add edda-ingestion dependency
2. crates/edda-serve/src/lib.rs -- add 6 route handlers, register in both routers, add integration tests

Files NOT modified:

• edda-ingestion crate -- fully complete
• edda-ledger -- schema V12 already present

Estimated size: ~350 lines (handlers + tests)

[fagemx]

Innovation: Ingestion API Routes + Integration Tests (GH-328)

Solution Approaches

Approach A: Thin Pass-Through Handlers (Recommended)

Each HTTP handler is a thin adapter that:

1. Deserializes the request
2. Opens the ledger
3. Calls the edda-ingestion public API directly
4. Serializes the response

Pros:

• Minimal new code (~200 lines for handlers)
• All business logic stays in edda-ingestion crate
• Easy to test (handlers are mechanical)
• Follows existing serve patterns exactly (e.g., post_approve_controls_patch delegates entirely)

Cons:

• Error messages from edda-ingestion are anyhow strings; need parsing for proper HTTP status codes

Mitigation: Pre-check existence/status in the handler before calling queue methods, matching the post_draft_approve pattern.

Approach B: Service Layer in edda-ingestion

Add a service module to edda-ingestion that returns typed errors (NotFound, Conflict) instead of anyhow strings.

Pros:

• Clean error types flow through to HTTP layer naturally
• Better separation of concerns

Cons:

• Over-engineering for 6 routes
• Modifies feat(ingestion): add trigger tables + evaluator engine #326/feat(ingestion): add suggestion queue + workflow #327 code that's already merged and tested
• YAGNI: only one consumer (edda-serve)

Verdict: Violates the project's YAGNI principle.

Approach C: Error Type Matching

Parse anyhow error messages with contains() to map to HTTP status codes.

Pros:

• No changes to edda-ingestion
• No pre-checks needed

Cons:

• Fragile string matching
• Changes to error messages break HTTP behavior silently

Verdict: Too fragile.

Recommended: Approach A with Pre-Checks

Route Design

POST /api/ingestion/evaluate

#[derive(Deserialize)]
struct EvaluateBody {
    event_type: String,
    source_layer: String,
    // Optional fields for building the record/suggestion
    source_refs: Option<Vec<SourceRef>>,
    summary: Option<String>,
    detail: Option<serde_json::Value>,
    tags: Option<Vec<String>>,
}

#[derive(Serialize)]
#[serde(rename_all = "camelCase")]
struct EvaluateResponse {
    action: String,               // "ingested", "queued", "skipped"
    record_id: Option<String>,    // present when ingested
    suggestion_id: Option<String>, // present when queued
    reason: Option<String>,       // present when queued (trigger reason)
}

Flow:

1. Parse body, validate source_layer is valid L0-L5
2. Call evaluate_trigger(event_type, source_layer)
3. Match result:
   • AutoIngest: build IngestionRecord (trigger_type=Auto), write to ledger, return 201 with recordId
   • SuggestIngest{reason}: build Suggestion, enqueue, return 200 with suggestionId + reason
   • Skip: return 200 with action="skipped"

Key decision: summary and detail should be required for auto-ingest (we need content to write), but evaluate should accept them as optional since the caller may just want to test the trigger. If auto-ingest triggers but no summary is provided, use a default: "{event_type} from {source_layer}".

POST /api/ingestion/records (manual)

#[derive(Deserialize)]
struct ManualIngestBody {
    event_type: String,
    source_layer: String,
    source_refs: Option<Vec<SourceRef>>,
    summary: String,            // Required for manual
    detail: serde_json::Value,  // Required for manual
    tags: Option<Vec<String>>,
}

Flow:

1. Validate source_layer
2. Build IngestionRecord with trigger_type=Manual
3. Write to ledger
4. Return 201 with recordId

GET /api/ingestion/records

#[derive(Deserialize)]
struct IngestionRecordsQuery {
    limit: Option<usize>,
    source_layer: Option<String>,
    trigger_type: Option<String>,
}

Flow:

1. Load all ingestion events: ledger.iter_events_by_type("ingestion")
2. Deserialize each payload to IngestionRecord
3. Apply optional filters (source_layer, trigger_type)
4. Apply limit (default 50)
5. Return JSON array

GET /api/ingestion/suggestions

No query params needed (always returns pending only).

Flow:

1. Create SuggestionQueue::new(&ledger)
2. Call list_pending()
3. Return JSON array

POST /api/ingestion/suggestions/{id}/accept

No body needed.

Flow:

1. Open ledger, acquire lock
2. Call SuggestionQueue::accept(id)
3. On success: return 200 with the IngestionRecord
4. On error: map to 404 or 409

POST /api/ingestion/suggestions/{id}/reject

No body needed.

Flow:

1. Open ledger, acquire lock
2. Call SuggestionQueue::reject(id)
3. On success: return 200 with { "ok": true }
4. On error: map to 404 or 409

Error Handling Strategy

For accept/reject, use the pre-check approach:

// Pre-check: does the suggestion exist and is it pending?
let row = ledger.get_suggestion(id)?;
let row = row.ok_or_else(|| AppError::NotFound(format!("suggestion not found: {id}")))?;
if row.status != "pending" {
    return Err(AppError::Conflict(format!(
        "suggestion {id} has status '{}', expected 'pending'",
        row.status
    )));
}

// Now safe to call queue method (no TOCTOU issue since we hold the lock)
let queue = SuggestionQueue::new(&ledger);
let record = queue.accept(id)?;  // Won't fail since we pre-checked

This is safe because the WorkspaceLock is held for the duration, preventing concurrent modifications. It exactly mirrors the post_draft_approve pattern.

Integration Test Plan

Test 1: Auto-ingest flow

POST /api/ingestion/evaluate { event_type: "decision.commit", source_layer: "L1", summary: "...", detail: {...} }
-> assert 201, action="ingested", recordId starts with "prec_"
GET /api/ingestion/records
-> assert contains the record

Test 2: Suggest-ingest flow -> accept

POST /api/ingestion/evaluate { event_type: "route.changed", source_layer: "L1", summary: "...", detail: {...} }
-> assert 200, action="queued", suggestionId starts with "sug_"
GET /api/ingestion/suggestions
-> assert 1 pending suggestion
POST /api/ingestion/suggestions/{id}/accept
-> assert 200, record with trigger_type="suggested"
GET /api/ingestion/suggestions
-> assert empty (accepted, no longer pending)

Test 3: Never-ingest flow

POST /api/ingestion/evaluate { event_type: "followup.draft", source_layer: "L1" }
-> assert 200, action="skipped"
GET /api/ingestion/records
-> assert empty

Test 4: Manual ingestion

POST /api/ingestion/records { event_type: "custom.event", source_layer: "L1", summary: "...", detail: {...} }
-> assert 201, recordId starts with "prec_"
GET /api/ingestion/records
-> assert 1 record with trigger_type="manual"

Test 5: Error cases

• Accept non-existent suggestion -> 404
• Reject non-existent suggestion -> 404
• Accept already-accepted suggestion -> 409
• Evaluate with invalid source_layer -> 400

Key Decisions

1. Thin handlers over service layer -- YAGNI, only one consumer
2. Pre-check pattern for accept/reject -- avoids fragile string matching, consistent with existing code
3. Default summary for evaluate -- enables trigger-testing without full payload
4. camelCase for all response bodies -- matches WIRE-01 convention
5. WorkspaceLock for write operations -- consistent with all other POST handlers in edda-serve

[fagemx]

Plan: Ingestion API Routes + Integration Tests (GH-328)

Overview

Add 6 HTTP API routes to edda-serve that expose the ingestion trigger engine and suggestion queue from edda-ingestion. Follows the thin pass-through handler pattern consistent with existing edda-serve code.

Pre-conditions

• feat(ingestion): add trigger tables + evaluator engine #326 merged (trigger tables + evaluator)
• feat(ingestion): add suggestion queue + workflow #327 merged (suggestion queue)
• edda-ingestion crate complete with all public API

Implementation Steps

Step 1: Add edda-ingestion dependency to edda-serve

File: crates/edda-serve/Cargo.toml

Change: Add under [dependencies]:

edda-ingestion = { path = "../edda-ingestion", version = "0.1.1" }

Verify: cargo check -p edda-serve

---

Step 2: Add request/response types for ingestion routes

File: crates/edda-serve/src/lib.rs

Add the following structs near the other route-specific types (around line 1630, near the existing note/decide types):

// ── Ingestion types ──

#[derive(Deserialize)]
#[serde(rename_all = "camelCase")]
struct EvaluateBody {
    event_type: String,
    source_layer: String,
    #[serde(default)]
    source_refs: Vec<edda_ingestion::SourceRef>,
    #[serde(default)]
    summary: Option<String>,
    #[serde(default)]
    detail: Option<serde_json::Value>,
    #[serde(default)]
    tags: Vec<String>,
}

#[derive(Serialize)]
#[serde(rename_all = "camelCase")]
struct EvaluateResponse {
    action: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    record_id: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    suggestion_id: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    reason: Option<String>,
}

#[derive(Deserialize)]
#[serde(rename_all = "camelCase")]
struct ManualIngestBody {
    event_type: String,
    source_layer: String,
    #[serde(default)]
    source_refs: Vec<edda_ingestion::SourceRef>,
    summary: String,
    detail: serde_json::Value,
    #[serde(default)]
    tags: Vec<String>,
}

#[derive(Deserialize)]
#[serde(rename_all = "camelCase")]
struct IngestionRecordsQuery {
    #[serde(default)]
    limit: Option<usize>,
    #[serde(default)]
    source_layer: Option<String>,
    #[serde(default)]
    trigger_type: Option<String>,
}

Verify: cargo check -p edda-serve

---

Step 3: Implement the 6 route handlers

File: crates/edda-serve/src/lib.rs

Add handlers after the existing route handlers (before the test module):

3a: POST /api/ingestion/evaluate

async fn post_ingestion_evaluate(
    State(state): State<Arc<AppState>>,
    body: Result<Json<EvaluateBody>, JsonRejection>,
) -> Result<impl IntoResponse, AppError> {
    let Json(body) = body.map_err(|e| AppError::Validation(e.body_text()))?;

    // Validate source_layer
    let layer: edda_ingestion::SourceLayer = body
        .source_layer
        .parse()
        .map_err(|e: String| AppError::Validation(e))?;

    let result = edda_ingestion::evaluate_trigger(&body.event_type, &body.source_layer);

    match result {
        edda_ingestion::TriggerResult::AutoIngest => {
            let ledger = state.open_ledger()?;
            let _lock = WorkspaceLock::acquire(&ledger.paths)?;

            let summary = body.summary.unwrap_or_else(|| {
                format!("{} from {}", body.event_type, body.source_layer)
            });
            let record = edda_ingestion::IngestionRecord {
                id: edda_ingestion::IngestionRecord::new_id("prec"),
                trigger_type: edda_ingestion::TriggerType::Auto,
                event_type: body.event_type,
                source_layer: layer,
                source_refs: body.source_refs,
                summary,
                detail: body.detail.unwrap_or(serde_json::json!({})),
                tags: body.tags,
                created_at: time_now_rfc3339(),
            };

            edda_ingestion::write_ingestion_record(&ledger, &record)?;

            Ok((
                StatusCode::CREATED,
                Json(EvaluateResponse {
                    action: "ingested".to_string(),
                    record_id: Some(record.id),
                    suggestion_id: None,
                    reason: None,
                }),
            ))
        }
        edda_ingestion::TriggerResult::SuggestIngest { reason } => {
            let ledger = state.open_ledger()?;
            let _lock = WorkspaceLock::acquire(&ledger.paths)?;

            let summary = body.summary.unwrap_or_else(|| {
                format!("{} from {}", body.event_type, body.source_layer)
            });
            let suggestion = edda_ingestion::Suggestion {
                id: edda_ingestion::Suggestion::new_id(),
                event_type: body.event_type,
                source_layer: layer,
                source_refs: body.source_refs,
                summary,
                suggested_because: reason.clone(),
                detail: body.detail.unwrap_or(serde_json::json!({})),
                tags: body.tags,
                status: edda_ingestion::SuggestionStatus::Pending,
                created_at: time_now_rfc3339(),
                reviewed_at: None,
            };

            let queue = edda_ingestion::SuggestionQueue::new(&ledger);
            let id = queue.enqueue(&suggestion)?;

            Ok((
                StatusCode::OK,
                Json(EvaluateResponse {
                    action: "queued".to_string(),
                    record_id: None,
                    suggestion_id: Some(id),
                    reason: Some(reason),
                }),
            ).into_response())
        }
        edda_ingestion::TriggerResult::Skip => {
            Ok((
                StatusCode::OK,
                Json(EvaluateResponse {
                    action: "skipped".to_string(),
                    record_id: None,
                    suggestion_id: None,
                    reason: None,
                }),
            ).into_response())
        }
    }
}

Note: The handler returns different status codes (201 for ingested, 200 for queued/skipped). Since the impl IntoResponse return type must be uniform, the queued/skipped branches need .into_response() and the function should return Result<Response, AppError> instead. Alternatively, always return 200 for simplicity. The plan document spec says:

• auto: { action: "ingested", record_id } -- 201
• suggest: { action: "queued", suggestion_id } -- 200
• skip: { action: "skipped" } -- 200

Best approach: return Result<Response, AppError> with explicit .into_response() on each branch.

3b: POST /api/ingestion/records (manual)

async fn post_ingestion_record(
    State(state): State<Arc<AppState>>,
    body: Result<Json<ManualIngestBody>, JsonRejection>,
) -> Result<impl IntoResponse, AppError> {
    let Json(body) = body.map_err(|e| AppError::Validation(e.body_text()))?;

    let layer: edda_ingestion::SourceLayer = body
        .source_layer
        .parse()
        .map_err(|e: String| AppError::Validation(e))?;

    let ledger = state.open_ledger()?;
    let _lock = WorkspaceLock::acquire(&ledger.paths)?;

    let record = edda_ingestion::IngestionRecord {
        id: edda_ingestion::IngestionRecord::new_id("prec"),
        trigger_type: edda_ingestion::TriggerType::Manual,
        event_type: body.event_type,
        source_layer: layer,
        source_refs: body.source_refs,
        summary: body.summary,
        detail: body.detail,
        tags: body.tags,
        created_at: time_now_rfc3339(),
    };

    edda_ingestion::write_ingestion_record(&ledger, &record)?;

    Ok((StatusCode::CREATED, Json(serde_json::json!({ "recordId": record.id }))))
}

3c: GET /api/ingestion/records

async fn get_ingestion_records(
    State(state): State<Arc<AppState>>,
    Query(params): Query<IngestionRecordsQuery>,
) -> Result<Json<Vec<edda_ingestion::IngestionRecord>>, AppError> {
    let ledger = state.open_ledger()?;
    let events = ledger.iter_events_by_type("ingestion")?;

    let mut records: Vec<edda_ingestion::IngestionRecord> = events
        .into_iter()
        .filter_map(|e| serde_json::from_value(e.payload).ok())
        .collect();

    // Apply filters
    if let Some(ref layer) = params.source_layer {
        records.retain(|r| r.source_layer.to_string() == *layer);
    }
    if let Some(ref tt) = params.trigger_type {
        records.retain(|r| {
            serde_json::to_value(r.trigger_type).ok()
                .and_then(|v| v.as_str().map(|s| s == tt))
                .unwrap_or(false)
        });
    }

    let limit = params.limit.unwrap_or(50);
    records.truncate(limit);

    Ok(Json(records))
}

3d: GET /api/ingestion/suggestions

async fn get_ingestion_suggestions(
    State(state): State<Arc<AppState>>,
) -> Result<Json<Vec<edda_ingestion::Suggestion>>, AppError> {
    let ledger = state.open_ledger()?;
    let queue = edda_ingestion::SuggestionQueue::new(&ledger);
    let pending = queue.list_pending()?;
    Ok(Json(pending))
}

3e: POST /api/ingestion/suggestions/{id}/accept

async fn post_suggestion_accept(
    State(state): State<Arc<AppState>>,
    AxumPath(id): AxumPath<String>,
) -> Result<Json<edda_ingestion::IngestionRecord>, AppError> {
    let ledger = state.open_ledger()?;
    let _lock = WorkspaceLock::acquire(&ledger.paths)?;

    // Pre-check for proper HTTP error codes
    let row = ledger.get_suggestion(&id)?
        .ok_or_else(|| AppError::NotFound(format!("suggestion not found: {id}")))?;
    if row.status != "pending" {
        return Err(AppError::Conflict(format!(
            "suggestion {id} has status '{}', expected 'pending'", row.status
        )));
    }

    let queue = edda_ingestion::SuggestionQueue::new(&ledger);
    let record = queue.accept(&id)?;
    Ok(Json(record))
}

3f: POST /api/ingestion/suggestions/{id}/reject

async fn post_suggestion_reject(
    State(state): State<Arc<AppState>>,
    AxumPath(id): AxumPath<String>,
) -> Result<Json<serde_json::Value>, AppError> {
    let ledger = state.open_ledger()?;
    let _lock = WorkspaceLock::acquire(&ledger.paths)?;

    // Pre-check for proper HTTP error codes
    let row = ledger.get_suggestion(&id)?
        .ok_or_else(|| AppError::NotFound(format!("suggestion not found: {id}")))?;
    if row.status != "pending" {
        return Err(AppError::Conflict(format!(
            "suggestion {id} has status '{}', expected 'pending'", row.status
        )));
    }

    let queue = edda_ingestion::SuggestionQueue::new(&ledger);
    queue.reject(&id)?;
    Ok(Json(serde_json::json!({ "ok": true })))
}

Verify: cargo check -p edda-serve

---

Step 4: Register routes in both routers

File: crates/edda-serve/src/lib.rs

Add to the production router (in serve() function, inside the protected_routes builder):

.route("/api/ingestion/evaluate", post(post_ingestion_evaluate))
.route("/api/ingestion/records", post(post_ingestion_record).get(get_ingestion_records))
.route("/api/ingestion/suggestions", get(get_ingestion_suggestions))
.route("/api/ingestion/suggestions/{id}/accept", post(post_suggestion_accept))
.route("/api/ingestion/suggestions/{id}/reject", post(post_suggestion_reject))

Add the same routes to the #[cfg(test)] fn router().

A helper function time_now_rfc3339() is needed. Check if one already exists in the serve crate -- if not, add a small utility (or inline it).

Verify: cargo check -p edda-serve

---

Step 5: Add integration tests

File: crates/edda-serve/src/lib.rs (inside #[cfg(test)] mod tests)

Test 5a: auto_ingest_via_evaluate

POST /api/ingestion/evaluate with decision.commit + L1
-> 201, action=ingested, recordId present
GET /api/ingestion/records
-> 1 record with matching event_type

Test 5b: suggest_then_accept

POST /api/ingestion/evaluate with route.changed + L1
-> 200, action=queued, suggestionId present
GET /api/ingestion/suggestions
-> 1 pending suggestion
POST /api/ingestion/suggestions/{id}/accept
-> 200, returns IngestionRecord
GET /api/ingestion/suggestions
-> empty (no more pending)
GET /api/ingestion/records
-> 1 record with trigger_type=suggested

Test 5c: never_ingest_skips

POST /api/ingestion/evaluate with followup.draft + L1
-> 200, action=skipped
GET /api/ingestion/records
-> empty

Test 5d: manual_ingestion

POST /api/ingestion/records with event_type + source_layer + summary + detail
-> 201, recordId present
GET /api/ingestion/records
-> 1 record with trigger_type=manual

Test 5e: accept_nonexistent_404

POST /api/ingestion/suggestions/sug_fake/accept
-> 404

Test 5f: reject_nonexistent_404

POST /api/ingestion/suggestions/sug_fake/reject
-> 404

Test 5g: suggest_then_reject

POST /api/ingestion/evaluate with route.changed + L1
-> 200, action=queued
POST /api/ingestion/suggestions/{id}/reject
-> 200
GET /api/ingestion/records
-> empty (rejected, not written)

Verify: cargo test -p edda-serve -- ingestion

---

Step 6: Final verification

cargo fmt --check -p edda-serve
cargo clippy -p edda-serve -- -D warnings
cargo test -p edda-serve
cargo test -p edda-ingestion

Definition of Done Mapping

• cargo build zero errors -> Step 1-4
• All API routes respond correctly -> Step 3-4
• Full flow integration tests pass -> Step 5
• cargo test -p edda-ingestion all pass -> Step 6

Risk Mitigations

1. time_now_rfc3339() helper: The serve crate may not have one. If not, add a private function matching the pattern in edda-ingestion/src/suggestion.rs:134-138.

2. Return type uniformity: post_ingestion_evaluate returns different status codes per branch. Use Result<Response, AppError> and .into_response() on each branch tuple.

3. Trigger type filter: TriggerType is a serde enum. To compare with a query string, serialize to value and compare, or add Display impl. The plan uses serialization comparison for simplicity.

4. Test router duplication: Both production and test routers need the same 5 route registrations (6 routes, but /api/ingestion/records handles both GET and POST). This is the existing pattern -- no way around it without refactoring the router setup, which is out of scope.

Commit Plan

Single commit:

feat(serve): add ingestion API routes + integration tests (GH-328)

[fagemx]

Work completed. PR created: #372

All local checks passing (fmt, clippy, 105 serve tests, 53 ingestion tests).