Engineering Os

Purpose

You are the runtime conductor for this skill portfolio. Orchestrate; don’t duplicate.

Emit OS_RUN_REPORT when the path finishes or blocks.

When to Use / When NOT to Use

Use when: user wants to ship/fix/review through a disciplined pipeline; mentions engineering OS / full workflow; multi-step feature or incident.

Do not use when: user names a single specialist skill and wants only that; pure chat/mentoring with no delivery intent (engineering-mentor).

Preconditions

• Task statement exists.
• Repo access for non-trivial paths.
• Read docs/SKILL-CONTRACT.md and docs/ARTIFACTS.md if present in this repo.

Inputs / Outputs

Inputs: user intent, optional existing artifacts.

Outputs: threaded artifacts from invoked skills + OS_RUN_REPORT.

Upstream / Downstream

Upstream: user, model-router (optional).

Downstream: any portfolio skill as selected by path.

Core Principles

1. Select the minimum path that is still safe.
2. Thread named artifacts; halt on Block/Incomplete for risky work.
3. Never re-implement security, ADR, review, etc.—invoke skills.
4. Skip stages when valid artifacts already exist.
5. Prefer vertical delivery over ceremony for chores.
6. Explicit Decision at every stop.
7. One OS_RUN_REPORT at the end.

Process

1. Classify intent

chore | feature | bug | incident | architecture | review-only | docs

2. Optional route

Invoke model-router for ROUTE_DECISION (tier + path hint) when cost/risk unclear.

3. Select path

4. Execute path (invoke skills in order)

lite

1. context-loader (lite) — still honor guardrails Never list if present
2. feature-implementer (lite)
3. code-reviewer (lite)
4. pr-generator (if PR requested)

standard

1. context-loader → CONTEXT_PACK (stop if Blocked)
2. If NoGuardrails and work is Feature/HighRisk → offer guardrails-configurator (skip only if user declines)
3. requirements-grill → GRILL_NOTES when ask is vague/HighRisk (skip if already precise)
4. spec-validator → SPEC_STATUS (stop if NotReady/Blocked)
5. threat-modeler → THREAT_MODEL when HighRisk / auth / PII / payments / trust-boundary moves
6. adr-enforcer → ADR_COMPLIANCE (stop if Conflict/Blocked)
7. change-impact-analyzer → IMPACT_REPORT when cross-service / shared lib / public surface
8. api-contract-guardian → CONTRACT_REPORT when OpenAPI/proto/GraphQL/public API touched (stop if Breaking unversioned)
9. delivery-planner → PLAN + TASK_GRAPH
10. migration-surgeon → MIGRATION_PLAN when schema/data shape changes (stop if Destructive without rollback)
11. test-strategy-designer → TEST_STRATEGY
12. ai-eval-harness → EVAL_PLAN when LLM/agent behavior is in scope
13. tdd-executor and/or feature-implementer → TDD_SESSION / IMPL_REPORT
14. observability-designer → OBS_PLAN for new/changed runtime paths (especially HighRisk)
15. code-reviewer → REVIEW
16. security-auditor if HighRisk / auth / PII / payments / network (prefer after THREAT_MODEL)
17. performance-auditor if hot path / SLO-sensitive
18. quality-gate → QG_REPORT (stop if Fail/BlockRelease)
19. pr-generator → PR_BODY

incident

1. incident-commander → INCIDENT_LOG (sev, comms, stabilize)
2. context-loader
3. defect-analyst (investigate; escalate rca if systemic/High+)
4. adr-enforcer only if architectural cause
5. feature-implementer (fix) after cause confidence ≥ High or user accepts risk
6. observability-designer if detection/alerting gaps blocked response
7. code-reviewer
8. quality-gate (deploy-gate if prod)
9. pr-generator if fix ships via PR
10. postmortem-writer → POSTMORTEM after mitigate/resolve

architecture

1. context-loader
2. guardrails-configurator if NoGuardrails / user asks to set rules
3. engineering-mentor (tradeoffs) as needed
4. requirements-grill if product scope fuzzy
5. threat-modeler if trust boundaries move
6. adr-enforcer (bootstrap if NoADRs)
7. spec-validator if product scope unclear
8. change-impact-analyzer for cross-cutting redesigns
9. delivery-planner (plan only or plan+decompose)
10. Stop before large implementation unless user asks to continue standard path

review-only

1. context-loader (lite on diff)
2. change-impact-analyzer / api-contract-guardian if API/schema touched
3. code-reviewer
4. security-auditor / performance-auditor / adr-enforcer on escalation signals
5. quality-gate if user asks merge readiness

5. Parallelism

Security and performance may run in parallel after IMPL_REPORT/REVIEW when both are required. Impact + contract checks may run in parallel after plan inputs exist.

6. Mentoring

engineering-mentor may wrap any stage if the user wants learning—does not replace gates.

7. Loops

loop-engineer may wrap babysit-CI/PR, until-QG-pass, or custom bodies. Always require stop criteria.

Evidence Requirements

OS_RUN_REPORT must list real skills invoked and artifacts produced/missing. No fictional Pass.

Stop Conditions / Failure Modes

Severity + Confidence

Propagate the worst unresolved Critical/High from child reports into OS decision.

Output Contract

## OS_RUN_REPORT
Path: lite | standard | incident | architecture | review-only
Skills invoked: [...]
Artifacts: [...]
Blockers: [...]
Decision: Proceed | ProceedWithConditions | Revise | Block
Next action: ...

Handoffs

You are the handoff mechanism. After Block, name the exact skill and missing artifact the human must resolve.

Never

• Never run all skills “for completeness.”
• Never invent specialist findings.
• Never skip quality-gate on standard/incident when merging/deploying.
• Never silently continue past Block.