Platform Three Context (eng-manager overflow)

Field	Value
Type	Agent Reference
Source	`~/.copilot/agents/_refs/eng-manager/platform-context.md`
Description	Not specified

Source Content

Platform Three Context (eng-manager overflow)

Reference for the Engineering Manager agent. The body of eng-manager.md links here instead of duplicating these conventions inline.

Stack detection (MANDATORY first step)

Before routing anything, read the repo and emit a Stack Snapshot. Never assume the stack — repos vary. Snapshot template:

Stack Snapshot
- Frontend:    <none | React+Vite | Astro+React | Next.js | other>
- Backend:     <none | Astro endpoints | Hono | Express | Go (Fiber) | other>
- DB:          <none | Postgres (CNPG) | SQLite | other> + ORM (Kysely / Drizzle / GORM / sqlc)
- Infra:       <none | Docker | k8s+Helm | ArgoCD | other>
- Monorepo:    <no | pnpm workspaces + Turborepo | Nx>
- Design:      <none | dmwd-io via Storybook MCP | Tailwind only>
- Pkg mgr:     <pnpm | npm | yarn | go mod>
- CI:          <none | GitHub Actions | other>
- Notable:     <Skaffold, Taskfile, OpenTelemetry, etc.>

Detection signals:

File / dir	Means
`astro.config.*`, `astro` in `package.json`	Astro+TS repo
`next.config.*`	Next.js repo
`vite.config.*` + `react`	React-only TS repo
`go.mod`	Go module
`.p3/helm/`, `Chart.yaml`	k8s+Helm repo
`pnpm-workspace.yaml`	TS monorepo
`Taskfile.yml`, `skaffold.yaml`	P3 conventions present
`dmwd` workspace dep / Storybook MCP wired	dmwd-io consumer
`kysely` / `drizzle` / `prisma` / `gorm` / `sqlc` in deps	ORM choice
`.github/workflows/`	CI present

For the canonical OSS-only defaults (only used when the repo is empty), see STANDARDS.md §2.

Standard Directory Structure

/project-root
  /.p3/                  # Kubernetes config (Helm charts, ArgoCD)
    /helm/{templates,values}
    /argocd/
  /cmd/{api,cli,worker}  # Go application entrypoints
  /internal/{api,service,repository,domain}
  /src/{components,layouts,pages}   # Astro frontend
  /docs/secrets/         # 1Password documentation
  /skaffold.yaml
  /Taskfile.yml
  /go.mod
  /package.json

Naming Conventions

Go packages: lowercase, single word or snake_case
Go files: lowercase_with_underscores.go
Go functions: PascalCase (exported), camelCase (unexported)
Kubernetes resources: kebab-case
1Password items: p3-<service>-<purpose> in vault platform-three
Database tables: snake_case, plural
API endpoints: /api/v1/resource (REST)

API Layout

/internal/api/<resource>/
  handler.go
  request.get.go
  request.post.go
  response.get.go
  response.post.go
  routes.go

Logging Standards (ADR-compliant)

Zap for all Go services
Structured JSON logs with tenant/user/request context
Required fields: request_id, trace_id, session_id, tenant, user, auth
Action-based event names: user_create_started, user_create_completed

Secrets

1Password Connect for ALL secrets (no raw k8s secrets)
Vault: platform-three
Item naming: p3-<service>-<type> (e.g. p3-myapp-database)
Always create docs/secrets/1password-requirements.md

Local Workflow

task dev or skaffold dev — local development
task test — run tests
task lint — run linters
task build — produce binaries
Commit + push — GitOps via ArgoCD picks up the change

Cross-cutting Concerns

When coordinating multiple specialists, verify alignment on:

Auth — backend middleware ↔ frontend state ↔ k8s secrets
Errors — structured backend errors ↔ user-friendly UI ↔ k8s error-rate alerts
Logging — structured everywhere, shared correlation fields
Monitoring — Prometheus metrics, client error tracking, ServiceMonitors
Configuration — Viper (Go), env vars (FE), ConfigMaps/Secrets (k8s)

Quality Gates

Before signing off on multi-agent work:

Code passes lint (golangci-lint, biome/eslint) and has tests
Secret requirements documented; OpenAPI / API contracts documented
Components integrate (env vars, health checks, contracts)
Secrets via 1Password; input validated at trust boundaries
Structured logging, metrics, traces wired end-to-end

Briefing Templates

Every brief leads with the Stack Snapshot so the specialist starts with the same picture I have.

Universal preamble (paste before any specialist brief)

Stack Snapshot
- Frontend:  ...
- Backend:   ...
- DB:        ...
- Infra:     ...
- Monorepo:  ...
- Design:    ...
- Pkg mgr:   ...
- CI:        ...
- Notable:   ...

To the Frontend specialist (Astro+TS or React+TS)

<Stack Snapshot>
Context: <what the user wants, in plain English>
Task: <component/page/endpoint>
Stack-specific:
  - If Astro: server endpoints under src/pages/api/, hydration directive choice, content collections.
  - If React+Vite: TanStack Router routes, TanStack Query for server state, Zustand for local.
Design system: dmwd-io first via dmwd/* tools; Tailwind only if dmwd-io unavailable.
Integration: <API contract location, Zod schema in packages/contracts>
Skills to invoke: <e.g. astro-architect, tanstack-router-architect, zod-schema-architect, react-perf-auditor>
Deliverables: components/pages/endpoints, Vitest + RTL tests, story for any new dmwd-io component.

To the Go Backend specialist

<Stack Snapshot>
Context: <what the user wants>
Task: <endpoint / service / worker>
Endpoints: <METHOD /path list>
DB: <models / migrations / Atlas vs goose>
Auth: <none / OIDC / token>
Skills to invoke: <golang-fiber-bootstrapper for new svc, api-designer for contract, postgres-performance for hot queries>
Deliverables: handler+service+repository layers, testify + testcontainers tests, OpenAPI via oapi-codegen, Atlas migrations, Helm chart in .p3/, 1Password secret doc.

To the Kubernetes specialist

<Stack Snapshot>
Context: <service to deploy>
Type: API / worker / CLI / operator
DB: CloudNativePG yes/no
Ingress: Traefik path/host
Secrets: <1Password item names>
Env: dev/staging/prod
Skills to invoke: <kubernetes-operator if CRD, github-actions-architect if CI changes, observability-designer for SLOs>
Deliverables: Helm chart in .p3/helm/, values per env, ArgoCD Application, Skaffold profile, 1Password secret doc, post-rollout verification checklist.

To the PostgreSQL DBA

<Stack Snapshot>
Context: <slow query / schema design / migration plan>
Skills to invoke: <postgres-performance for EXPLAIN work, database-designer for schema>
Deliverables: annotated EXPLAIN plans, CREATE INDEX CONCURRENTLY migrations, before/after benchmark in bench/.

To the UX Designer

<Stack Snapshot>
Context: <what the user wants>
Skills to invoke: <ui-design-system if tokens/components, frontend-design for distinctive UI, ux-researcher-designer for research>
Deliverables: dmwd-io-aligned design tokens, component spec, copy, accessibility notes.

Routing Patterns

Simple delegation — single domain, hand off immediately
Sequential — backend → frontend → k8s when there are hard dependencies
Parallel — independent slices in different domains run concurrently, then integration check
Iterative — ambiguous request → clarify before delegating