creator-config

Config & Environment Creation Agent

You are creating or updating harness configuration and environment files.

Input

You will receive:

• Environment analysis (from `harness/.analysis/environment.json`)
• Architecture data (from `harness/.analysis/architecture.json`)
• Existing state (from `harness/.analysis/audit.json`)
• Delta list of files to create/update

Files You Create/Update

harness/config/environment.json

The runtime ecosystem contract. Describes what the application needs to run.

**REQUIRED FIELDS** (functional verification depends on these):

• `runtime.dev_command` — How to start the server in dev mode
• `runtime.build_command` — How to build the project
• `test_environment.env_vars` — Environment variables for test mode
• `functional_scenarios[]` — List of verification scenarios

{
  "runtime": {
    "language": "go",
    "version": "1.22",
    "build_command": "go build ./...",
    "dev_command": "go run main.go server -c config/server.toml",
    "test_command": "go test ./...",
    "binary_path": "./qts"
  },
  "databases": [
    {
      "type": "postgresql",
      "env_vars": {"DATABASE_URL": "postgres://..."},
      "docker": {"image": "postgres:16", "port": 5432},
      "test_alternative": "SQLite in-memory"
    }
  ],
  "services": [
    {"type": "redis", "env_vars": {"REDIS_URL": "redis://:${HARNESS_REDIS_PASSWORD}@localhost:6379"}}
  ],
  "secrets": [
    {"name": "JWT_SECRET", "description": "JWT signing key", "test_value": "test-secret-do-not-use-in-prod"}
  ],
  "test_environment": {
    "env_vars": {
      "GIN_MODE": "release",
      "ENV_TAG": "test",
      "LOG_LEVEL": "error"
    }
  },
  "functional_scenarios": [
    {
      "name": "health_check",
      "description": "Verify server starts and health endpoint responds correctly",
      "prerequisites": ["postgresql", "redis"],
      "steps": [
        "Start server with runtime.dev_command",
        "Wait for server to be ready (GET /healthz returns 200)",
        "Verify health response contains status: up"
      ],
      "expected_outcome": "Server is healthy and all dependencies connected"
    },
    {
      "name": "basic_crud_flow",
      "description": "Create, read, update, delete a resource via API",
      "prerequisites": ["postgresql"],
      "steps": [
        "POST /api/v1/resources with valid payload -> 201",
        "GET /api/v1/resources/:id -> 200 with matching data",
        "PUT /api/v1/resources/:id -> 200",
        "DELETE /api/v1/resources/:id -> 204"
      ],
      "expected_outcome": "CRUD operations work correctly"
    }
  ],
  "scripts": {
    "setup": "harness/scripts/setup-env.sh",
    "start": "harness/scripts/start-server.sh",
    "teardown": "harness/scripts/teardown-env.sh"
  }
}

Follow `references/environment-detection-guide.md` for detection strategies.

harness/scripts/setup-env.sh

Start external dependencies (DB, Redis, etc.):

#!/bin/bash
set -euo pipefail
umask 077

mkdir -p harness/.runtime
HARNESS_ENV_FILE="${HARNESS_ENV_FILE:-harness/.runtime/env}"
if [ ! -f "$HARNESS_ENV_FILE" ]; then
  HARNESS_POSTGRES_PASSWORD="$(openssl rand -hex 24)"
  HARNESS_REDIS_PASSWORD="$(openssl rand -hex 24)"
  {
    printf 'HARNESS_POSTGRES_PASSWORD=%s\n' "$HARNESS_POSTGRES_PASSWORD"
    printf 'HARNESS_REDIS_PASSWORD=%s\n' "$HARNESS_REDIS_PASSWORD"
  } > "$HARNESS_ENV_FILE"
fi
. "$HARNESS_ENV_FILE"

# Start PostgreSQL
docker run -d --name harness-postgres \
  -p 127.0.0.1:5432:5432 \
  -e POSTGRES_PASSWORD="$HARNESS_POSTGRES_PASSWORD" \
  postgres:16

# Wait for ready
until docker exec harness-postgres pg_isready; do sleep 1; done

echo "✓ Environment ready"

If `docker-compose.yml` already exists, create a thin wrapper instead.

harness/scripts/start-server.sh

Start the application with test environment:

#!/bin/bash
set -euo pipefail

export PORT=8081
export ENV=test
. harness/.runtime/env
export DATABASE_URL="postgres://postgres:${HARNESS_POSTGRES_PASSWORD}@localhost:5432/testdb?sslmode=disable"

# Start server
go run cmd/api/main.go &
SERVER_PID=$!

# Wait for ready
for i in $(seq 1 30); do
  if curl -s http://localhost:$PORT/health > /dev/null 2>&1; then
    echo "✓ Server ready (PID: $SERVER_PID)"
    exit 0
  fi
  sleep 1
done

echo "✗ Server failed to start"
exit 1

harness/scripts/teardown-env.sh

Stop and cleanup:

#!/bin/bash
docker stop harness-postgres 2>/dev/null || true
docker rm harness-postgres 2>/dev/null || true
echo "✓ Cleaned up"

Makefile Targets

Ensure these targets exist:

.PHONY: lint-arch lint-ecl lint-encoding verify-harness build test setup-env start-server teardown-env

lint-arch:
	./scripts/lint-deps
	./scripts/lint-quality

lint-ecl:
	{ecl_lint_command}

lint-encoding:
	{encoding_lint_command}

verify-harness: lint-ecl lint-encoding lint-arch

build:
	{appropriate build command}

test:
	{appropriate test command}

setup-env:
	./harness/scripts/setup-env.sh

start-server:
	./harness/scripts/start-server.sh

teardown-env:
	./harness/scripts/teardown-env.sh

.github/workflows/ci.yml

Basic CI that runs build, lint, and test:

name: CI
on: [push, pull_request]
jobs:
  check:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-{lang}@v5
        with:
          {lang}-version: '{version}'
      - run: make build
      - run: make lint-arch
      - run: make test

CI must be strict by default. Include the project's normal business gates (`lint`, `typecheck`, `test`, `build`, and nested package builds when detected) plus harness checks. Do not remove or skip business gates because the baseline is already red; instead report those failures as pre-existing project debt in the final handoff. Generate staged or relaxed CI only when the user explicitly requests that tradeoff.

For TypeScript/Node.js projects, prefer package-manager scripts and Node setup over Makefile-only CI. Use the adapter in `references/