@structor-dev/cli 0.1.0

package/template/ai/ARCHITECTURE.md.tpl

@@ -0,0 +1,35 @@
+# {{PROJECT_NAME}} Architecture
+
+This document captures the durable architecture map for {{PROJECT_NAME}}.
+
+## System Shape
+
+- Harness repo: `{{HARNESS_REPO_NAME}}`
+- Consumer repos:
+{{CONSUMER_REPOS_LIST}}
+- Active harness contracts and contracts views live in `ai/contracts` and `ai/views`.
+
+## Ownership Boundaries
+
+- The harness owns shared policy, contracts, routing, and validation
+  expectations.
+- Consumer repos own implementation, local tests, runtime behavior, and
+  deployment-specific details.
+- Cross-repo invariants belong in `ai/contracts/*`.
+- Product-owned behavior contracts should be explicit and versionable through
+  `ai/contracts/*.contract.json`.
+
+## Module Guidance
+
+- Prefer deep modules that hide decisions behind clear APIs.
+- Avoid scattered coordination logic across unrelated files.
+- Keep names precise enough that the domain model is obvious.
+- Reuse existing types and abstractions before creating new ones.
+- Make shared interfaces explicit; avoid moving contract-owned logic into consumer
+  overlays.
+
+## Open Architecture Notes
+
+- Add repo-specific module maps as you onboard each consumer repo.
+- Add ADRs only for durable trade-offs that would surprise a future reader.
+- Keep bootstrap and worktree contracts close to workspace entrypoints.

package/template/ai/CODEX-HOOKS.md.tpl

@@ -0,0 +1,23 @@
+# Codex Hooks
+
+Codex hooks provide lightweight local guardrails for `{{PROJECT_NAME}}`.
+
+## Scope
+
+- Hooks may emit context or deny clearly unsafe actions.
+- Hooks must be deterministic, local, and dependency-free.
+- Hooks must not write files, call networks, run subprocess orchestration, or
+  mutate remote services.
+- Hooks are local guardrails, not a complete security boundary. They complement
+  sandboxing, permission controls, code review, CI policy, and secret
+  management.
+
+## Validation
+
+Run:
+
+```bash
+node scripts/check-codex-hooks.mjs
+```
+
+The hook contract lives in `ai/contracts/codex-hooks.md`.

package/template/ai/DECISIONS.md.tpl

@@ -0,0 +1,22 @@
+# Decisions
+
+Record durable harness decisions here.
+
+## Format
+
+- Date:
+- Decision:
+- Context:
+- Consequences:
+
+## Initial Decisions
+
+### Harness owns policy; runner owns execution
+
+- Date: initial generation
+- Decision: This repository owns harness policy, contracts, task shape, review
+  rules, and validation. Runtime orchestration belongs outside this repo.
+- Context: Keeping policy separate from execution makes the harness reusable
+  across model systems and runners.
+- Consequences: Runner behavior may consume this repo, but must not become the
+  canonical source of policy.

package/template/ai/DESIGN.md.tpl

@@ -0,0 +1,22 @@
+# {{PROJECT_NAME}} Design Direction
+
+Use this document for durable product and interface design direction when the
+consumer repos include user-facing surfaces.
+
+## Experience Principles
+
+- Define the tone and interaction expectations.
+- Define accessibility and responsiveness expectations.
+- Keep design rules tied to product needs, not decoration.
+
+## Interface Boundaries
+
+- Consumer repos own implementation details and component code.
+- The harness may define review criteria, product language, and cross-repo
+  consistency expectations.
+
+## Review Notes
+
+- Add examples, screenshots, or design references only when they are stable
+  enough to guide future work.
+

package/template/ai/HARNESS-ENGINEERING.md.tpl

@@ -0,0 +1,107 @@
+# Harness Engineering Standard
+
+An engineering harness is the durable, versioned system of context, contracts,
+validation, review policy, quality tracking, and feedback loops that makes
+AI-assisted engineering reliable and repeatable.
+
+This harness is optimized for agent legibility: future agents should be able to
+discover intent, boundaries, and validation paths from repo-local artifacts
+instead of chat history or human memory.
+
+## Harness, Not Runner
+
+- The harness defines what must be true.
+- A runner decides when and how work executes.
+- The harness owns policy, contracts, templates, quality, and validation.
+- Runtime state, polling, PR automation, dashboards, auto-merge, and repair
+  loops belong outside the canonical docs layer unless explicitly authorized.
+
+## System Of Record
+
+- Repo-local docs under `ai/*` are the system of record.
+- Knowledge in chat or external tools is invisible until encoded here.
+- Root `AGENTS.md` and `CLAUDE.md` stay short and route into `ai/*`.
+- Large always-loaded instruction blobs are prohibited.
+- Decisions that explain durable harness changes belong in `ai/DECISIONS.md`.
+
+## Progressive Disclosure
+
+Agents should load:
+
+1. the entrypoint map
+2. the current task
+3. the routed docs
+4. the relevant contract or review skill
+5. implementation files after boundaries are clear
+
+The goal is targeted context, not maximum context. If an agent needs to load
+the whole repo to understand the task, the harness is under-specified.
+
+## Enforced Invariants
+
+Advisory prose is not enough. Important architecture, safety, and task-shape
+rules should be mechanically checked when practical.
+
+Good harness checks:
+
+- validate structure, links, manifests, task metadata, and review-skill shape
+- fail with remediation-oriented messages an agent can act on
+- prefer narrow static checks over broad fragile interpretation
+- keep protected surfaces human-gated
+- stay independent of product runtime state unless explicitly documented
+
+## First-Class Artifacts
+
+- Product, architecture, workflow, and design docs explain intent.
+- Contracts encode boundaries and compatibility expectations.
+- Task briefs carry machine-readable risk, autonomy, model, repo, and path
+  metadata.
+- Plans capture multi-step work without becoming runtime state.
+- Quality grades expose weak areas honestly.
+- Review skills define repeatable evaluator behavior.
+- Garbage collection converts repeated mistakes into durable rules or checks.
+
+## Consumer Repo Legibility
+
+Consumer repos should expose enough local commands, docs, and checks for agents
+to inspect and validate work without guessing:
+
+- install, lint, test, build, dev, and health commands where applicable
+- critical smoke paths and safe local validation commands
+- required environment variables or local-service prerequisites
+- fixture, migration, screenshot, log, and observability expectations
+- root `AGENTS.md` and/or `CLAUDE.md` pointers back to this harness
+
+## Long-Running Work Readiness
+
+Long-running work needs handoff artifacts before it needs a runner. Task briefs
+must make decomposition, validation, review routing, and recovery expectations
+explicit enough that a fresh agent can continue after a context reset.
+
+Before a task is delegated to a runner, the harness should define:
+
+- the path contract and protected contracts
+- bootstrap commands and expected context files
+- required validation evidence
+- evaluator or review-skill routing
+- stop conditions and human approval gates
+- rollback or recovery path
+
+## Definition Of Done
+
+This harness is production-grade when:
+
+1. Agents can discover the right context without loading the entire repo.
+2. Product, architecture, contracts, decisions, and workflow policy are
+   versioned in `ai/*`.
+3. Task specs are bounded by machine-checkable metadata.
+4. Important architecture and safety rules are mechanically enforced where
+   practical.
+5. Validation evidence is required and structured.
+6. Repeated agent mistakes are captured and converted into durable fixes.
+7. Quality is graded and updated over time.
+8. Consumer repos expose agent-legible validation and observability hooks.
+9. Future runner integration can consume the harness without owning policy.
+10. Protected surfaces remain human-gated.
+11. OpenAI/Codex and Anthropic/Claude Code can start from native entrypoints
+    without duplicating canonical policy.

package/template/ai/HARNESS.md.tpl

@@ -0,0 +1,53 @@
+# {{PROJECT_NAME}} Engineering Harness
+
+This repo is the canonical harness for {{PROJECT_NAME}}. It defines shared
+guidance, contracts, task structure, review policy, and validation checks.
+
+It does not implement product behavior and it is not a runner.
+
+## What The Harness Owns
+
+- shared workflow and model-neutral guidance
+- shared product, architecture, design, and vocabulary docs
+- context routing
+- contracts and boundary rules
+- task templates and task metadata expectations
+- review procedures
+- validation scripts
+- workspace bootstrap checks and consumer entrypoint routing
+- model/client startup surfaces and local compatibility validators
+- quality tracking
+- repeated-mistake capture
+
+## What The Harness Does Not Own
+
+- long-running polling
+- agent session lifecycle
+- PR lifecycle automation
+- dashboards
+- auto-merge
+- production autonomous execution
+- runtime state stores
+- repair-loop daemons
+- external client automation that is not validated as a local harness guardrail
+
+## Harness vs Runner
+
+The harness answers what must be true. A runner answers when and how work is
+scheduled and executed.
+
+Future runners may consume this harness as read-only policy input. They must
+not become the policy source of truth.
+
+## Workspace Bootstrap
+
+Use:
+
+```sh
+node scripts/bootstrap-workspace.mjs
+```
+
+This installs workspace-level pointer files and checks that configured consumer
+repos can route agents back to the harness. It skips existing files by default.
+Use `--dry-run` to preview writes and `--force` only after reviewing existing
+consumer or workspace entrypoints.

package/template/ai/HUB.md.tpl

@@ -0,0 +1,53 @@
+# {{PROJECT_NAME}} Harness Hub
+
+This is the routing layer for the {{PROJECT_NAME}} engineering harness.
+
+## Baseline
+
+Always read:
+
+- `./AGENTS.md` or the local entrypoint
+- `./ai/AGENTS.md`
+- `./ai/context.md`
+
+## Routing
+
+- Product, user journeys, or business context:
+  `./ai/PRODUCT-SUMMARY.md`, `./ai/PRODUCT.md`
+- Architecture, repo boundaries, or module design:
+  `./ai/ARCHITECTURE.md`
+- UI or design direction:
+  `./ai/DESIGN.md`
+- Harness policy, bootstrap, validation, or model overlay changes:
+  `./ai/HARNESS.md`, `./ai/HARNESS-ENGINEERING.md`, `./ai/READINESS.md`,
+  `./ai/QUALITY.md`, `./ai/DECISIONS.md`, `./ai/knowledge-manifest.json`
+- Codex/Claude client surfaces, `.codex/**`, `.claude/**`, or overlay drift:
+  `./ai/HARNESS.md`, `./ai/HARNESS-ENGINEERING.md`, `./ai/QUALITY.md`,
+  `./ai/CODEX-HOOKS.md`,
+  and the matching generated client validator
+- Workspace, repo ownership, local stack, session bootstrap, or validation
+  ownership:
+  `./ai/workspace/REPOS.md`, `./ai/workspace/SYSTEM-MAP.md`,
+  `./ai/workspace/SESSION-BOOTSTRAP.md`, `./ai/workspace/LOCAL-STACK.md`,
+  `./ai/workspace/TEST-STRATEGY.md`
+- Runner or automation questions:
+  `./ai/WORKFLOW.md`, `./ai/RUNNER-SAFETY.md`,
+  `./ai/RUNNER-READINESS.md`, `./ai/VERSIONING.md`
+- Contracts or repo boundaries:
+  `./ai/contracts/README.md` and the matching contract doc
+- Task template changes:
+  `./ai/templates/README.md` and the matching template
+- Generated HTML review views:
+  `./ai/views/index.html` plus canonical Markdown, JSON, and YAML sources
+- Shared specs:
+  `./ai/specs/README.md` and the matching spec
+- Review requests:
+  `./ai/skills/README.md` and the matching review skill
+- Repeated agent mistakes:
+  `./ai/AGENT-GARBAGE-COLLECTION.md`
+
+## Load Rules
+
+- Load the smallest doc set that can answer the task.
+- Add topical docs only when the task clearly needs them.
+- Do not load every doc by default.

package/template/ai/PRODUCT-SUMMARY.md.tpl

@@ -0,0 +1,28 @@
+# {{PROJECT_NAME}} Product Summary
+
+This document captures the short product context agents need before proposing
+or changing user-facing behavior.
+
+## Product
+
+- Name: {{PROJECT_NAME}}
+- Primary consumer repo: {{PRIMARY_CONSUMER_NAME}}
+- Consumer repos:
+{{CONSUMER_REPOS_LIST}}
+
+## Users
+
+- Primary users are defined as any actors that consume the product surface from
+  {{PRIMARY_CONSUMER_NAME}} or downstream consumer repos.
+- Product value is measured by how reliably each actor reaches intended outcome
+  with the fewest failure handoffs.
+
+## Core Workflows
+
+- Keep a single workflow map per critical actor in the relevant task brief.
+- Track entrypoint, validation, decision points, and durable handoff/output.
+- Link detailed specs or active task briefs when they exist.
+
+## Current Focus
+
+- Keep this section short and update it when product direction changes.

package/template/ai/PRODUCT.md.tpl

@@ -0,0 +1,32 @@
+# {{PROJECT_NAME}} Product Context
+
+This is the durable product context for the {{PROJECT_NAME}} engineering
+harness. Agents should treat this as the source of truth for product semantics.
+
+## Problem
+
+The harness exists to keep every consumer repo aligned on the same business
+meaning, shared vocabulary, and user-facing invariants.
+
+- Preserve the end-to-end value chain from input to outcome.
+- Surface the failure modes that must be handled explicitly.
+- Keep behavior choices traceable to a durable contract, not to local convenience.
+
+## Product Model
+
+- Define the core domain objects for this product and keep names consistent across
+  all repos.
+- Define ownership of each object and where source-of-truth transitions happen.
+- Define which terms are equivalent and which are not. Do not silently merge terms.
+
+## User Journeys
+
+- Document the expected happy path from first user intent to completed outcome.
+- Define recovery paths and observable fallback behavior for every step that can fail.
+- Keep implementation details out unless needed to clarify ownership boundaries.
+
+## Boundaries
+
+- Product behavior belongs in consumer repos.
+- Shared product language and cross-repo invariants belong in this harness.
+- If implementation and product context disagree, update one deliberately.

package/template/ai/QUALITY.md.tpl

@@ -0,0 +1,37 @@
+# Harness Quality
+
+This scorecard tracks harness readiness. Keep grades evidence-based and update
+them when validation or policy changes.
+
+| Domain | Grade | Evidence | Enforced by | Blocking gaps |
+| --- | --- | --- | --- | --- |
+| Entrypoints | B | `AGENTS.md`, `CLAUDE.md` | `scripts/validate-governance.mjs` | Customize after initial generation |
+| Context routing | B | `ai/HUB.md`, `ai/context.md` | Manual review | Add project-specific routing as needed |
+| Contracts | B | `ai/contracts/*` | `scripts/check-template-governance.mjs`, manual review | Replace starter contracts with project contracts |
+| Task shape | B | `ai/templates/task-brief-template.md` | `scripts/check-task-template.mjs` | Fill concrete project issue metadata and path contracts |
+| Review skills | B | `ai/skills/*` | Manual review | Customize review inputs and evaluator routing |
+| Readiness contract | B | `ai/READINESS.md`, `scripts/check-readiness.mjs` | `scripts/check-readiness.mjs`, manual review | Run post-generation machine gates and accept manual review domains |
+| Runner boundary | A | `ai/RUNNER-SAFETY.md` | Manual review | Keep runtime out of harness |
+| Workspace bootstrap | B | `scripts/bootstrap-workspace.mjs`, `scripts/check-workspace.mjs` | `node scripts/check-workspace.mjs` | Run after consumer repos are cloned |
+
+## Production-Grade Checklist
+
+- Entry points are short maps, not large manuals.
+- The hub routes agents to the smallest relevant context.
+- Task briefs include risk, autonomy, model, repo, path, validation, review,
+  and recovery metadata.
+- Contracts define repository boundaries and protected surfaces.
+- Validation scripts check every invariant that can be checked cheaply and
+  safely.
+- `ai/READINESS.md` distinguishes machine gates from manual review domains.
+- Validation failures include enough context for an agent to repair drift.
+- Consumer repos expose local commands and evidence hooks.
+- Repeated review feedback is captured in `ai/AGENT-GARBAGE-COLLECTION.md`.
+- Runner integration remains read-only until a separate runtime contract is
+  approved.
+
+## Update Rule
+
+When a grade changes, update the evidence and the blocking gap in the same
+edit. Do not improve a grade based on intent alone; use validation output,
+contract coverage, or review evidence.

package/template/ai/READINESS.md.tpl

@@ -0,0 +1,39 @@
+# Harness Readiness
+
+This file defines the post-generation readiness contract for the
+{{PROJECT_NAME}} harness. Readiness is a gate with evidence, not a numeric
+score and not a golden semantic diff against an ideal harness.
+
+## Verdicts
+
+- PASS: required machine gates pass and manual review domains are accepted for
+  the current project.
+- FAIL: any required machine gate fails.
+- MANUAL REVIEW REQUIRED: machine gates pass, but project-specific context,
+  contracts, routing, or review guidance still need human judgment.
+
+## Required Machine Gates
+
+| Gate | Command | Required evidence |
+| --- | --- | --- |
+| Governance validation | `node scripts/validate-governance.mjs` | Command exits 0 |
+| Workspace bootstrap preview | `node scripts/bootstrap-workspace.mjs --dry-run` | Planned pointer writes are expected |
+| Workspace bootstrap | `node scripts/bootstrap-workspace.mjs` | Command exits 0 or reports only intentional skips |
+| Workspace check | `node scripts/check-workspace.mjs` | Command exits 0 |
+| Overlay drift | `node scripts/check-overlay-drift.mjs` | Required when OpenAI or Anthropic support is enabled |
+| Codex hooks | `node scripts/check-codex-hooks.mjs` | Required when Codex hooks are enabled |
+| Claude compatibility | `node scripts/check-claude-compatibility.mjs` | Required when Anthropic support is enabled |
+
+## Manual Review Domains
+
+- `ai/context.md` names the real project, repos, and operating assumptions.
+- `ai/HUB.md` routes agents to the smallest useful context.
+- `ai/contracts/*` reflects real repo boundaries and protected surfaces.
+- `ai/templates/task-brief-template.md` matches the team's task intake shape.
+- `ai/skills/*` names review inputs that are available in this workspace.
+- `ai/QUALITY.md` records evidence and blocking gaps for each readiness domain.
+
+## Update Rule
+
+When readiness changes, update command evidence and `ai/QUALITY.md` in the same
+edit. Do not promote readiness based on intent alone.

package/template/ai/RUNNER-READINESS.md.tpl

@@ -0,0 +1,14 @@
+# Runner Readiness
+
+This checklist is the gate before implementing any runner that consumes this
+harness.
+
+## Required Before Runner Work
+
+- Harness validation passes.
+- Task metadata is machine-checkable.
+- Path contracts are documented.
+- Dry-run artifact format is defined.
+- First runner phase performs no external writes.
+- Runtime state lives outside canonical docs.
+- Protected surfaces remain human-gated.

package/template/ai/RUNNER-SAFETY.md.tpl

@@ -0,0 +1,21 @@
+# Future Runner Safety
+
+This document defines safety policy a future runner should honor. It is not an
+active runtime implementation.
+
+## Protected Surfaces
+
+Future runners should require human review for:
+
+- architecture or shared contracts
+- authentication or authorization
+- billing or payment behavior
+- secrets or environment variables
+- infrastructure or deployment configuration
+- database migrations or production data
+- large refactors across repo boundaries
+
+## External Actions
+
+Pushes, merges, paid external actions, tracker writes, and production mutations
+require explicit authorization and belong in a separate observable runner.

package/template/ai/VERSIONING.md.tpl

@@ -0,0 +1,16 @@
+# Versioning
+
+Harness policy changes should preserve existing generated repo behavior unless
+the task explicitly calls for a breaking change.
+
+## Compatibility
+
+- Keep existing script names stable.
+- Add new validation as additive checks when possible.
+- Document breaking changes in `ai/DECISIONS.md`.
+
+## Release Boundary
+
+The harness can define release criteria and evidence. It must not publish,
+deploy, tag, or mutate remote systems unless a human explicitly authorizes that
+action in the current task.

package/template/ai/WORKFLOW.md.tpl

@@ -0,0 +1,42 @@
+# Agent Workflow Policy
+
+This is harness policy for AI-assisted engineering tasks. It is not a runtime
+daemon contract and it does not start or control agent sessions.
+
+## Load Order
+
+1. Read the task brief.
+2. Read `ai/HUB.md`.
+3. Read the smallest routed doc set needed for the task.
+4. Read any named contract or review skill.
+
+## Execution Rules
+
+- Work only in authorized repos and paths.
+- Keep changes within `allowed_paths` when provided.
+- Do not touch `forbidden_paths`.
+- Make the smallest change that satisfies the task.
+- Stop when task intent conflicts with harness contracts.
+- State expected file changes, preserved contracts, validation commands, and
+  unresolved risks before editing.
+- Keep handoff notes current when work spans multiple sessions or context
+  resets.
+
+## Validation Rules
+
+- Run every safe validation command listed in the task.
+- Capture commands run, failures, skipped checks, and reasons.
+- Fix validation failures in the smallest relevant scope.
+- If validation cannot run, report the blocker explicitly instead of implying
+  coverage.
+
+## Handoff Rules
+
+Long-running work should leave enough state for a fresh agent to continue
+without reconstructing intent from chat:
+
+- current goal and accepted non-goals
+- files changed and files intentionally avoided
+- validation already run and remaining validation
+- decisions made and open questions
+- known risks, rollback path, and human approval gates

package/template/ai/context.md.tpl

@@ -0,0 +1,17 @@
+# {{PROJECT_NAME}} Harness Context
+
+## Current Focus
+
+- Keep canonical AI engineering policy versioned in this harness.
+- Make consumer repo work discoverable, bounded, and verifiable.
+- Keep model overlays and consumer entrypoints thin.
+
+## Known Fragile Areas
+
+- Drift between model-specific overlays.
+- Consumer repos duplicating or contradicting harness policy.
+- Harness docs growing too large to route effectively.
+
+## Consumer Repos
+
+{{CONSUMER_REPOS_LIST}}

package/template/ai/contracts/README.md.tpl

@@ -0,0 +1,23 @@
+# Contracts
+
+Contracts define cross-repo invariants. They do not implement behavior.
+
+## Index
+
+- `repo-boundaries.md`: repository ownership boundaries
+- `app-legibility.md`: commands, health checks, and validation evidence expected
+  from consumer repos
+- `api-boundary.md`: API ownership and compatibility expectations
+- `security-boundary.md`: protected surfaces and human approval gates
+- `codex-hooks.md`: local hook behavior and safety limits
+- `release-flow.md`: release and external mutation safety
+- `github-safety.md`: remote repository mutation guardrails
+
+Contract JSON manifests use the `*.contract.json` suffix and are checked by
+`node scripts/check-contract-manifests.mjs`.
+
+## Rule
+
+Contracts are authoritative for what must stay true. Consumer repos implement
+the contracts. If implementation and contract disagree, update one deliberately
+instead of allowing drift.

package/template/ai/contracts/api-boundary.contract.json.tpl

@@ -0,0 +1,11 @@
+{
+  "id": "api-boundary",
+  "name": "API Boundary Contract",
+  "version": "1.0.0",
+  "owners": ["{{HARNESS_REPO_NAME}}"],
+  "affectedRepos": {{CONSUMER_REPO_NAMES_JSON}},
+  "requiredFiles": [
+    "ai/contracts/api-boundary.md"
+  ],
+  "validation": ["node scripts/validate-governance.mjs"]
+}

package/template/ai/contracts/api-boundary.md.tpl

@@ -0,0 +1,17 @@
+# API Boundary
+
+Use this contract to document API ownership and compatibility expectations.
+
+## Required Fields
+
+- Owning repo:
+- Consumers:
+- Backward compatibility rule:
+- Versioning or migration rule:
+- Required validation:
+
+## Drift That Should Block
+
+- Breaking a documented API without a migration plan.
+- Moving source-of-truth behavior into a consumer that does not own it.
+- Changing external contracts without updating task and validation evidence.

package/template/ai/contracts/app-legibility.contract.json.tpl

@@ -0,0 +1,11 @@
+{
+  "id": "app-legibility",
+  "name": "App Legibility Contract",
+  "version": "1.0.0",
+  "owners": ["{{HARNESS_REPO_NAME}}"],
+  "affectedRepos": {{CONSUMER_REPO_NAMES_JSON}},
+  "requiredFiles": [
+    "ai/contracts/app-legibility.md"
+  ],
+  "validation": ["node scripts/validate-governance.mjs"]
+}

package/template/ai/contracts/app-legibility.md.tpl

@@ -0,0 +1,24 @@
+# App Legibility
+
+Consumer repos must expose enough local information for agents to inspect and
+validate work without guessing.
+
+## Expected Local Signals
+
+- install command
+- lint command
+- test command
+- build command
+- health or smoke-check command when available
+- required environment variable documentation
+- artifact or log locations when validation creates them
+
+## Validation Evidence Shape
+
+Final reports should include:
+
+- commands run
+- commands skipped and why
+- affected repos and contract IDs
+- protected surfaces reviewed
+- artifact or log paths when produced