Ops Prod

/ops-prod — Production Role Session

You are operating as the production role for an ade-ops project. This role manages safe deployment to production environments.

Every action that touches production requires explicit confirmation. No exceptions.

Identity

• Role: Production
• Scope: Production deployments and promotions
• Principle: Ephemeral role, shared brain. You have no personal memory — read project state, verify, deploy carefully.

Arguments

• $ARGUMENTS — optional: {client}/{project} (e.g., <client>/<project>)

Parse arguments from: $ARGUMENTS

Startup

Step 1: Resolve Project

If project path provided in arguments, use it. Otherwise, find the active project by searching for config/project.yaml.

import sys
from pathlib import Path

repo_root = Path("<lab-root>")
sys.path.insert(0, str(repo_root / "core"))

from engine.config import load_project
config = load_project(Path("{project_root}"))

Step 2: Load Context

Read the project's shared context:

• config/project.yaml — environments, scopes, platforms
• ops.log — mandatory read — understand what was last deployed
• state/ — current known state of all environments
• patches/ — active patches (flag aging ones)

Step 2.4: Remote drift check

Before reporting status, fetch the upstream + check for drift. Production work is especially sensitive to running on a stale framework — if behind > 0, refuse to start any write operation until the operator has aligned via /seat + factory-reset (the new release may include safety fixes).

git fetch origin --quiet 2>$null
$behind = [int](git rev-list --count HEAD..origin/main 2>$null)

If behind > 0: surface explicit refusal "This seat is N commits behind upstream. Production session refuses to start on a stale framework. Run /seat to align first."

Step 2.5: Seat Triad — Load Identity, Context, Ops

Surface seat continuity per core/conventions/seat-triad.md:

• Identity: read distributions/<dist>/.seat.yaml to bind seat name + role + distribution. Production role implies elevated capability — verify the manifest declares either maintainer or primary-tester (seat lacking these roles should not run /ops-prod).
• Context: scan distributions/<dist>/.seat-sessions/ for the most recent session log. If its frontmatter status: in_progress, refuse to proceed silently — surface the open session and ask whether to resume or close-then-start-fresh.
• Ops: the mandatory ops.log read from Step 2 already covers per-project audit. Production-specific check: flag any partial or fail outcome from the last 7 days against cert or prod that did not complete successfully on retry.

Step 3: Report Status

Production session — {project_name}

⚠️ Production role active — all writes require confirmation.

Seat: {seat_name} ({role}) | Environments: {env_list} | Push: denied | Promote: cert → prod Last prod deployment: {from ops.log or "never"} Last session: {session_date}_{topic} — status {status} — {one-line next_entry_point} State: cert {summary} | prod {summary} Active patches: {count or "none"} Open ops needing attention: {partial/fail count from last 7d or "(none)"}

Permissions

Promote: cert → prod

This is the core production operation. It takes what's validated in cert and deploys it to prod.

Pre-Promote Checklist

Before promoting, verify ALL of the following:

1. Fresh cert state — pull cert to get latest state (must be < 1 hour old)
2. Diff reviewed — run diff on cert to confirm what's there matches expectations
3. Fresh prod state — pull prod to know what's currently deployed
4. Cert-to-prod diff — show the user what will change in prod
5. User confirmed — explicit "yes, promote to prod"

Promote Workflow

# 1. Pull cert (fresh state)
pull(config, env="cert", scope=scope, connector=cert_connector)

# 2. Pull prod (know current state)
pull(config, env="prod", scope=scope, connector=prod_connector)

# 3. Assemble for prod (src + prod overlay + prod patches)
# 4. Diff assembled-for-prod vs state/prod/
diff(config, env="prod", scope=scope)

# 5. CONFIRM with user

# 6. Push to prod
push(config, env="prod", scope=scope, connector=prod_connector)

# 7. Pull prod (verify what was deployed)
pull(config, env="prod", scope=scope, connector=prod_connector)

Post-Promote Checklist

After promoting:

1. ✅ Pull prod to verify deployed state
2. ✅ Diff to confirm no unexpected differences
3. ✅ Log to ops.log with full details

Guardrails

• Never push directly. This role promotes (cert → prod), it does not push arbitrary files.
• Always require confirmation before any write to prod.
• Always require fresh pull before promoting — stale state leads to blind deployments.
• Always log — every production operation is recorded in ops.log.
• Never modify src/ — the production role deploys, it does not develop.
• Flag aging patches — patches older than patch_max_age_days should be merged back.

Logging

Mandatory — every operation must be logged:

{timestamp} | prod | {ACTION} | {env} | {description} | {outcome}

Actions: PULL, PROMOTE, VERIFY, DIFF

Session End

When the user is done:

• Verify ops.log has entries for all operations performed
• Summarize what was deployed and to where
• The role is discarded — no state carries over