Setting up Lifecycle across graph8-com/infra and graph8-com/g8 — file by file, query by query, day by day.

# GitHub UI:
graph8-com/infra/settings/branches → Add classic rule for `main`
  ✓ Require a pull request before merging
  ✓ Require approvals (1)
  ✓ Require review from Code Owners
  ✓ Require status checks: terraform, validate-k8s
  ✓ Require linear history

graph8-com/g8/settings/branches → same rule for `main` and `qa`
  ✓ Require status checks: code-quality jobs

# Create migration file:
mkdir -p services/mbm/migrations
cat > services/mbm/migrations/20260517_skill_invocations.sql <<'SQL'
-- (paste the CREATE TABLE from §3 Data model)
SQL

# Apply via your existing migration runner (Atlas or Alembic):
make migrate

# services/mbm/internal/trace/handler.go
package trace

type TraceRow struct {
  EngineerID    string  `json:"engineer_id"`
  SkillName     string  `json:"skill_name"`
  Repo          string  `json:"repo,omitempty"`
  Runtime       string  `json:"runtime"`
  Model         string  `json:"model,omitempty"`
  LatencyMS     int     `json:"latency_ms,omitempty"`
  Status        string  `json:"status"`
  InputTokens   *int    `json:"input_tokens,omitempty"`
  OutputTokens  *int    `json:"output_tokens,omitempty"`
  CostUSDCents  *int    `json:"cost_usd_cents,omitempty"`
  ArgHash       string  `json:"arg_hash,omitempty"`
}

func Handler(w http.ResponseWriter, r *http.Request) {
  // 1. validate API token from header
  // 2. decode JSON
  // 3. INSERT row → return 202 with id
}

# services/lifecycle-trace-mcp/src/server.ts (minimal MCP server)
import { Server } from "@modelcontextprotocol/sdk/server";

const server = new Server({ name: "lifecycle-trace", version: "0.1.0" });

server.setRequestHandler("tools/call", async (req, ctx) => {
  const t0 = Date.now();
  try {
    return await ctx.delegate(req);
  } finally {
    fetch(`${process.env.MBM_URL}/v1/trace`, {
      method: "POST",
      headers: { "Authorization": `Bearer ${process.env.MBM_TOKEN}` },
      body: JSON.stringify({
        engineer_id: process.env.GITHUB_USER,
        skill_name: req.params.name,
        runtime: "claude-code-local",
        latency_ms: Date.now() - t0,
        status: "success",
      }),
    }).catch(() => {}); // fire-and-forget; never block the user
  }
});

# Register in both repos: .claude/mcp.json
{
  "mcpServers": {
    "lifecycle-trace": {
      "command": "npx",
      "args": ["-y", "@graph8/lifecycle-trace-mcp"],
      "env": { "MBM_URL": "https://mbm.graph8.com" }
    }
  }
}

-- The query that powers the panel:
SELECT engineer_id,
       count(*)                                        AS fires_30d,
       count(*) FILTER (WHERE status = 'success')      AS successful,
       count(DISTINCT skill_name)                      AS unique_skills,
       (SELECT skill_name FROM skill_invocations s2
        WHERE s2.engineer_id = s1.engineer_id
        GROUP BY skill_name ORDER BY count(*) DESC LIMIT 1) AS top_skill,
       CASE
         WHEN count(*) > 300 THEN 'excellent'
         WHEN count(*) > 150 THEN 'strong'
         WHEN count(*) > 50  THEN 'developing'
         WHEN count(*) > 20  THEN 'untapped'
         ELSE 'spinning?'
       END AS utilization
FROM skill_invocations s1
WHERE ts > now() - interval '30 days'
GROUP BY engineer_id
ORDER BY fires_30d DESC;

-- The query:
SELECT skill_name AS agent,
       count(*)                                       AS runs,
       sum(cost_usd_cents) / 100.0                    AS cost_usd,
       (SELECT count(*) FROM github_prs p
        WHERE p.head_branch LIKE 'axon/' || s.skill_name || '/%'
          AND p.merged_at > now() - interval '30 days') AS prs_merged
FROM skill_invocations s
WHERE runtime = 'k8s-job'
  AND ts > now() - interval '30 days'
GROUP BY skill_name
ORDER BY cost_usd DESC;

7. Lowercase normalizer · g8/.github/workflows/normalize-mbm-trigger.yml
   Trigger: issue_comment.created
   If body matches /@(?i)mbm\s+review/ but not /@mbm review/ → re-post lowercase

8. Sync token guard · g8/.github/workflows/sync-main-to-qa.yml
   Add step 1: if [ -z "${{ secrets.SYNC_BOT_TOKEN }}" ]; then exit 1; fi

9. pr_fixer attempt-4 · tenants/graph8-eng/agents/pr_fixer/prompt.md
   Append to the Retry-cap section: on attempt 4, label mbm/needs-input,
   post summary comment tagging the author, stop.

10. Retire pr_cleanup + rage_click_detector
    Decide: add TaskSpawner entries to triggers.yaml OR rm -rf the agent dirs.

# g8/.github/workflows/test-writer-on-pr.yml
name: Test-writer on PR
on:
  pull_request:
    types: [opened, synchronize]
    paths: ['**/*.py']
jobs:
  scan:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Find new public funcs without tests
        run: ./scripts/find-untested.sh
      - name: Dispatch test-writer if needed
        if: steps.scan.outputs.untested != ''
        run: gh api repos/${{ github.repository }}/dispatches \
             -f event_type='spawn-test-writer' \
             -f client_payload[pr]='${{ github.event.number }}'

# tenants/graph8-eng/agents/agent_health/prompt.md (excerpt)
Every day at 05:00 UTC:
1. Query agent_health_stats: yesterday's runs, PRs, reverts per axon agent.
2. Compute survival_rate = merged_not_reverted / opened.
3. Compute 7-day moving average.
4. If any agent < 80%, flag in Roam digest.
5. If any agent < 50%, page on-call.
6. Write today's row to agent_health_stats.

# tenants/graph8-eng/crons.yaml — add:
- name: agent-health-daily
  schedule: "0 5 * * *"
  agent: agent_health

13. engineer_scoring.go (half-day): Go file + 8 tests, POST /v1/grade/engineer.
    Update infra/.claude/commands/assign-prds.md to call the endpoint.

14. auto-promote-qa-to-main.yml (3 hr): hourly check, opens PR if QA green ≥48h.

15. Remove continue-on-error from bandit (half-day, parallel):
    Run bandit on main, fix findings, flip the flag.

16. Skill consolidation round 1 (1 hr, parallel): /commit folded into /ship.
    Skill count: 22 → 21.

17. mbm_critic agent (4 hr): daily cron classifies override patterns.
    Already-scaffolded prompt at tenants/graph8-eng/agents/mbm_critic/.

18. skill_mortality.go (2 hr, parallel): weekly SQL, auto-open deprecation issues.

19. Cloudflare Worker (5 hr): /tenants/<id>/webhook accepts GH webhooks, HMAC-validates,
    creates Task CRs via MBM API. Don't cut over yet — that's tomorrow.

20. Skill consolidation round 2 (1 hr, parallel):
    /assign-prds + /capacity-check → /capacity. Skill count: 21 → 20.

21. Cut over 5xx-error label to webhook (2 hr).
    Edit tenants/graph8-eng/triggers.yaml; measure p50 dispatch latency.
    Expected: ~1 hour → under 60 seconds.

22. Run the 8-metric acceptance grid (1 hr).
    Walk every metric, run every verification command. Target: 6 / 8 green.

23. Record the 10-minute demo (2 hr).
    Loom walking through: vision page → click stat → drill into skill →
    live engineer-utilization dashboard → webhook latency proof →
    one closed loop in action.

Day 8–9   · Roll remaining labels to webhooks (1 day, agent-driven).
Day 9–11  · knowledge_compactor (context_fetches table + agent + daily cron).
Day 10–11 · Ruff blocking flip (next CI ratchet step).
Day 11–13 · Top-5 cross-repo contracts + contract_test_runner agent.
Day 12–14 · bug_predictor agent (comment-only at first).
Day 13–14 · onboarding agent · add joined field to engineer-domains.json.
Day 13    · Skill consolidation round 3 (/review + /security-review).
Day 14    · Skill consolidation round 4 (/start branches).