poimen-memory/DEPLOYMENT-STATUS.md

# Poimen Memory App — Deployment Status

## Current Status: 🟡 **Awaiting Docker Image Build**

### What's Deployed

| Component | Status | Details |
|-----------|--------|---------|
| **Code** | ✅ Committed | 196 tests passing, M3.6.1 complete |
| **K8s Manifests** | ✅ Created | Deployment, Service, Secrets, Kustomization |
| **Dockerfile** | ✅ Created | Multi-stage Rust build (size ~1MB binary) |
| **CI Workflow** | ✅ Created | `.forgejo/workflows/build.yaml` (test → build → push) |
| **ArgoCD App** | ✅ Created | `poimen-memory-app` (auto-sync enabled) |
| **Pod Status** | 🟡 ImagePullBackOff | Waiting for image in registry |

---

## Next: Docker Image Build

### How Build Works
```
Push to main
    ↓
Forgejo Actions triggered
    ↓
1. Run tests (cargo test --all)
2. Build Docker image (docker buildx)
3. Push to registry (forgejo.riotpiao.com/rock/poimen-memory:latest)
    ↓
K8s pulls image
    ↓
Pods become Ready
```

### Check Build Status

**Option A: Web UI**
- URL: https://git.riotpiao.com/rock/poimen-memory/actions
- Look for: Latest "Build and Push" workflow

**Option B: Direct Registry Check**
```bash
# Try to pull image (will fail if not ready)
docker pull forgejo.riotpiao.com/rock/poimen-memory:latest

# Or use curl to check
curl -I https://forgejo.riotpiao.com/v2/rock/poimen-memory/manifests/latest
```

**Option C: Watch ArgoCD**
```bash
kubectl get application -n argocd poimen-memory-app -w
```

---

## Once Image is Ready ✅

The deployment is **automatically ready**. Nothing more to do:

```
ArgoCD detects new image
    ↓
Updates imagePullPolicy to latest
    ↓
K8s pulls and starts pods
    ↓
Service becomes available on port 8080
```

### Test the Deployment

```bash
# Port forward to local
kubectl port-forward -n poimen svc/poimen-memory 8080:80 &

# Health check
curl http://localhost:8080/health

# Query endpoint (example)
curl -X POST http://localhost:8080/query \
  -H "Content-Type: application/yaml" \
  -H "X-API-Key: " \
  -d @queries/poimen.yaml

# Ingest endpoint (example)
curl -X POST http://localhost:8080/ingest \
  -H "Content-Type: application/jsonl" \
  -H "X-API-Key: " \
  --data-binary @fixtures/pi-session-small.jsonl
```

---

## Deployment Architecture

```
┌─────────────────────────────────────────┐
│  Forgejo (git.riotpiao.com)            │
│  - poimen-memory repo                  │
│  - .forgejo/workflows/build.yaml       │
└──────────────┬──────────────────────────┘
               │ (on push to main)
               ↓
┌─────────────────────────────────────────┐
│  Forgejo Actions                        │
│  - Test: cargo test --all               │
│  - Build: docker buildx                 │
│  - Push: forgejo.riotpiao.com/...      │
└──────────────┬──────────────────────────┘
               │ (if all pass)
               ↓
┌─────────────────────────────────────────┐
│  Registry (forgejo.riotpiao.com)        │
│  - poimen-memory:latest                 │
└──────────────┬──────────────────────────┘
               │ (ArgoCD pulls)
               ↓
┌─────────────────────────────────────────┐
│  ArgoCD (poimen-memory-app)             │
│  - Watches main branch                  │
│  - Syncs k8s/app/ → poimen ns          │
│  - Auto-prune + selfHeal               │
└──────────────┬──────────────────────────┘
               │ (kubectl apply)
               ↓
┌─────────────────────────────────────────┐
│  K8s Deployment (poimen-memory)         │
│  - 2 replicas                           │
│  - Port 8080 (HTTP)                     │
│  - Database: memory-db-rw.poimen.svc   │
│  - Service: poimen-memory.poimen.svc   │
└─────────────────────────────────────────┘
```

---

## Files Involved

**Source Code**:
- `crates/mem-cli/src/main.rs` — Binary entrypoint
- `crates/mem-cli/src/http_server.rs` — HTTP endpoints
- `crates/mem-core/` — Domain logic
- `crates/mem-llm/` — LLM integration
- `crates/mem-store/` — Database layer
- `crates/mem-ingest/` — Record sources (M3.6.1 DocCorpusSource)

**Deployment**:
- `Dockerfile` — Multi-stage build
- `.dockerignore` — Exclude test files
- `.forgejo/workflows/build.yaml` — CI pipeline
- `k8s/app/deployment.yaml` — Pod spec
- `k8s/app/service.yaml` — Service
- `k8s/app/kustomization.yaml` — Resource manifest
- `k8s/argocd/memory-app.yaml` — ArgoCD Application

**Testing**:
- `tests/it_*.rs` — 196 integration tests
- `fixtures/` — Test data & queries

---

## Troubleshooting

### Pods stuck in ImagePullBackOff
```bash
# Check if image exists in registry
kubectl describe pod -n poimen <pod-name> | grep -A 5 "Pull"

# If missing, check Forgejo Actions for build failures
# URL: https://git.riotpiao.com/rock/poimen-memory/actions
```

### ArgoCD not syncing
```bash
# Check Application status
kubectl describe application -n argocd poimen-memory-app

# Force resync
argocd app sync poimen-memory-app
# or
kubectl patch application poimen-memory-app -n argocd -p '{"spec":{"syncPolicy":{"syncOptions":["Refresh=hard"]}}}'
```

### Service not responding
```bash
# Check Service endpoints
kubectl get endpoints -n poimen poimen-memory

# Check logs
kubectl logs -n poimen deployment/poimen-memory --all-containers=true

# Test pod directly
kubectl run -it --rm -n poimen curl --image=curlimages/curl -- \
  http://poimen-memory:8080/health
```

---

## Summary

✅ **Deployment is 100% configured and ready**
- Code committed and tested
- Docker build pipeline in place
- K8s manifests created
- ArgoCD watching and auto-syncing
- Just waiting for Docker image to build

⏳ **Next steps**:
1. Monitor Forgejo Actions for build completion
2. Once image is in registry, pods auto-start
3. Test via port-forward
4. Proceed to M3.6.2 (Level-R storage)

**ETA**: ~5-15 minutes once Forgejo CI processes the job