ai-delivery-workflow 0.2.2

package/skills/ai-delivery-execute-test/SKILL.md

@@ -0,0 +1,34 @@
+---
+name: ai-delivery-execute-test
+description: Execute one independent risk-based test work package against an immutable candidate and controlled environment. Use when candidate verification assigns a bounded functional, integration, end-to-end, security, performance, accessibility, compatibility, migration, or recovery validation objective.
+---
+
+# Execute Test Work Package
+
+Observe and report. Do not repair the candidate, change test expectations to make a failure pass, or inspect private internals unless the work package explicitly defines a white-box security objective.
+
+## Artifact Location
+
+Write every test report, log index, evidence manifest, and workflow document produced by this skill under project `.workflow/`, defaulting version-scoped outputs to `.workflow/iterations/<iteration-id>/<node-id>/`. Raw external logs may remain in controlled systems only when their immutable references and checksums are recorded in `.workflow/`.
+
+## Task State
+
+1. Invoke `$ai-delivery-checkpoint-task` before preflight to recover or initialize the task snapshot.
+2. Checkpoint after every meaningful artifact, gate, validation, merge, deployment action, or other external milestone, and before compaction or interruption.
+3. Before returning, finish the snapshot as `completed`, `blocked`, `failed`, or `interrupted`, with actual outputs, evidence, blockers, and one idempotent next action. A Hook event alone never proves completion.
+
+## Workflow
+
+1. Read the work package, approved source artifacts, candidate identity, environment identity, applicable standards, evidence requirements, and exact page/canvas/file/element references for UI or prototype-conformance scope.
+2. Confirm prerequisites and isolate test data.
+3. Derive additional cases from independent requirements and risk sources when allowed.
+4. Execute through public interfaces and retain reproducible commands, inputs, outputs, timestamps, and environment references.
+5. Distinguish product failure, test defect, environment defect, flaky behavior, and blocked execution.
+6. Minimize a failure to a reproducible case without mutating production code.
+7. Submit every failure to `$ai-delivery-triage-failure`.
+
+## Output
+
+Produce test cases or an exploratory charter, execution evidence, coverage references, observed results, defects, blocked scope, and a `pass`, `fail`, or `blocked` decision for this package.
+
+Read [test-execution-contract.md](references/test-execution-contract.md).

package/skills/ai-delivery-execute-test/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "Execute Test Work"
+  short_description: "Execute one risk-based independent test work package"
+  default_prompt: "Use $ai-delivery-execute-test to execute the assigned independent test work package."

package/skills/ai-delivery-execute-test/references/test-execution-contract.md

@@ -0,0 +1,7 @@
+# Test Execution Contract
+
+Record test task ID, candidate ID, environment ID, source and risk references, page/canvas/prototype-file/element IDs when UI-bearing, prerequisites, inputs, commands or actions, expected result, actual result, timestamps, logs or screenshots, cleanup, and decision.
+
+Use stable defect IDs for failures. Preserve raw evidence before summarizing it. Identify flaky, blocked, environment, test-design, and product failures separately.
+
+Do not mutate candidate artifacts, product code, migrations, IaC, configuration, or approved expected results.

package/skills/ai-delivery-execute-work-package/SKILL.md

@@ -0,0 +1,53 @@
+---
+name: ai-delivery-execute-work-package
+description: Execute one architecture-constrained technical work package against its exact confirmed prototype using a dynamically assigned capability role and test-driven development. Use only when a develop-iteration work package defines its objective, scope, dependencies, prototype references when UI-bearing, public test seam, stack, commands, expected outputs, and completion evidence.
+---
+
+# Execute Technical Work Package
+
+Implement only the assigned package. Do not broaden scope, choose a different stack, approve your own change, or repair unrelated defects.
+
+## Artifact Location
+
+Write every work-package document, TDD record, evidence manifest, and handoff record produced by this skill under project `.workflow/`, defaulting version-scoped outputs to `.workflow/iterations/<iteration-id>/<node-id>/`. Source code, automated test source, and non-document build artifacts remain in their declared modification scopes.
+
+## Task State
+
+1. Invoke `$ai-delivery-checkpoint-task` before preflight to recover or initialize the task snapshot.
+2. Checkpoint after every meaningful artifact, gate, validation, merge, deployment action, or other external milestone, and before compaction or interruption.
+3. Before returning, finish the snapshot as `completed`, `blocked`, `failed`, or `interrupted`, with actual outputs, evidence, blockers, and one idempotent next action. A Hook event alone never proves completion.
+
+## Preflight
+
+1. Read the work package, source baselines, applicable standards, confirmed test seam, repository instructions, and exact UI handoff, product reconciliation, experience-change mapping, prototype-set/member revisions, management/review/impact checksums, and page/canvas/file/element mappings when the package is UI-bearing. Require every mapped change to be `ready-for-development` and its action to be one of `create|update|remove|migrate|no-code`.
+2. Verify the current branch and worktree with `$ai-delivery-manage-git`.
+3. Inspect the current code and tests before planning edits.
+4. Stop on missing dependencies, prototype or page/canvas/file identity mismatch, overlapping ownership, ambiguous acceptance behavior, or an infeasible architecture. Return evidence to the orchestrator.
+
+## TDD Loop
+
+For one vertical behavior at a time:
+
+1. Write a behavior test through the confirmed public interface.
+2. Run it and retain evidence that it fails for the expected reason.
+3. Implement the minimum behavior needed to pass.
+4. Run the focused test and retain Green evidence.
+5. Run relevant regression tests.
+6. Repeat for the next behavior.
+
+Avoid private-method tests, internal collaborator mocks, tautological expectations, and bulk horizontal test creation. Mock only external system boundaries when a real controlled dependency is impractical.
+
+Perform cleanup or refactoring only from a Green checkpoint and expose it to independent review; do not hide behavior changes inside refactoring.
+
+## Finish
+
+- Run architecture-specified format, lint, type, build, test, migration, and security commands.
+- Update task-to-experience-change traceability and advance implemented rows through the state CLI; update technical documentation, configuration catalogs, and migration/rollback notes when affected.
+- Record deviations and TDD exceptions explicitly.
+- Commit only files in the allowed scope and produce a review packet with commands and evidence.
+
+Read [work-package-contract.md](references/work-package-contract.md).
+
+## Handoff
+
+Submit the change to `$ai-delivery-review-change`. A passing self-check is not approval.

package/skills/ai-delivery-execute-work-package/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "Execute Technical Work"
+  short_description: "Implement one architecture-constrained technical work package"
+  default_prompt: "Use $ai-delivery-execute-work-package to implement the assigned technical work package."

package/skills/ai-delivery-execute-work-package/references/work-package-contract.md

@@ -0,0 +1,20 @@
+# Work Package Contract
+
+A package is executable only when it declares:
+
+- stable task, iteration, and slice IDs;
+- objective and observable completion behavior;
+- approved source and standards references;
+- exact ready UI handoff, aligned product reconciliation, actionable experience-change IDs with create/update/remove/migrate/no-code actions, prototype-set identity/checksum, relevant member IDs/revisions/review-bundle checksums, management/review/impact checksums, and page/canvas/file/element IDs when UI-bearing;
+- required capability role;
+- allowed and forbidden modification scope;
+- predecessor outputs;
+- stack, versions, and commands;
+- confirmed public TDD seam;
+- expected code, test, data, configuration, and documentation outputs;
+- completion checks and evidence paths;
+- risk, compatibility, migration, and rollback impact.
+
+Return `blocked` rather than infer missing behavior or expand scope.
+
+Retain Red evidence, Green evidence, regression results, final commands, changed-file inventory, traceability, deviations, and TDD exceptions in the review packet.

package/skills/ai-delivery-manage-git/SKILL.md

@@ -0,0 +1,60 @@
+---
+name: ai-delivery-manage-git
+description: Enforce the AI delivery Git model using a protected production main, cumulative product development lines, planned-version and work-package branches, explicit release branches, hotfix branches, immutable version/release tags, and serialized production transitions. Use whenever creating, validating, merging, freezing, tagging, cleaning, or advancing delivery Git state.
+---
+
+# Manage Delivery Git
+
+Perform controlled Git transitions. Never represent Dev, SIT, staging, production, or rollback as branches.
+
+## Repository Boundary
+
+Read `.workflow/config/workspace.yaml` and execute every `line/*`, `version/*`, `work/*`, `release/*`, `release-fix/*`, `hotfix/*`, code `main`, and `version-ready/*` operation in the configured code repository. The workflow repository keeps shared process facts on `workflow/<workspace-id>` and only creates `workflow-ready/<version-id>/rN` after the corresponding version manifest is committed. Never create application branches or Tags in the workflow repository, and never treat the workflow fact branch as production code history.
+
+## Artifact Location
+
+Write every Git decision, transition record, scope declaration, and workflow document produced by this skill under project `.workflow/`, defaulting version-scoped outputs to `.workflow/iterations/<iteration-id>/<node-id>/`. Git metadata and repository configuration remain in their native locations.
+
+## Task State
+
+1. Invoke `$ai-delivery-checkpoint-task` before preflight to recover or initialize the task snapshot.
+2. Checkpoint after every meaningful artifact, gate, validation, merge, deployment action, or other external milestone, and before compaction or interruption.
+3. Before returning, finish the snapshot as `completed`, `blocked`, `failed`, or `interrupted`, with actual outputs, evidence, blockers, and one idempotent next action. A Hook event alone never proves completion.
+
+## Branch Model
+
+- `main`: protected production-success lineage;
+- `line/<product-id>`: latest verified cumulative development lineage, which may remain ahead of production;
+- `version/<version-id>-<slug>`: one planned cumulative version;
+- `work/<version-id>/<task-id>-<slug>`: one dynamic technical work package;
+- `release/<release-id>-<slug>`: one explicit user-requested release candidate;
+- `release-fix/<release-id>/<defect-id>`: one isolated release-candidate correction;
+- `hotfix/<hotfix-id>-<slug>`: urgent correction from the current production Tag.
+
+Reject environment branches (`dev`, `sit`, `staging`, `production`), `rollback-*`, role-named branches, direct protected-branch commits, and force pushes to protected history.
+
+## Work Package Operations
+
+1. Create every planned-version branch from the latest `line/<product-id>` head and every work branch from its planned-version baseline.
+2. Create an isolated worktree for every parallel AI package.
+3. Verify declared modification scope and prevent overlapping parallel write ownership.
+4. Require TDD evidence, independent review, and CI before merge.
+5. Prefer squash merge from work to planned version and retain task traceability in delivery artifacts.
+6. Remove completed worktrees and temporary branches only after confirming their changes and evidence are retained.
+
+## Release Operations
+
+1. At planned-version closeout, create immutable code `version-ready/<version-id>/rN`, fast-forward code `line/<product-id>`, commit workflow materials, then create workflow `workflow-ready/<version-id>/rN`; stop without changing code `main`.
+2. Serialize production release transitions only after explicit user release intent.
+3. Create `release/<release-id>-<slug>` from the selected target's exact version-ready Tag. Never merge each intermediate Tag or build from a movable line/version branch head.
+4. Apply any release-only correction on `release-fix/*`, create a new release candidate, and repeat impacted verification.
+5. Freeze and Tag the exact tested release commit before production deployment. Never move or reuse a release Tag.
+6. Promote the same artifact digest through environments; Git branches do not select environment state.
+7. After successful production verification, fast-forward `main` to the exact deployed commit. Same-version redeploy may leave `main` unchanged.
+8. After failed deployment and image rollback, keep `main` unchanged and preserve failed release and version Tags.
+
+## Hotfix Operations
+
+Create a hotfix from the current production Tag, run the shortened but complete explicit release path, and update `main` only after production verification. Synchronize the hotfix into `line/<product-id>` and rerun impact analysis. Mark every release-ready candidate that does not contain the hotfix commit `stale`.
+
+Read [git-policy.md](references/git-policy.md) before mutating Git state. Use non-interactive commands, protect user changes, and stop before destructive or ambiguous operations.

package/skills/ai-delivery-manage-git/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "Manage Delivery Git"
+  short_description: "Manage iteration branches, worktrees, tags, and release locks"
+  default_prompt: "Use $ai-delivery-manage-git to perform the required transition in the correct workflow or code repository."

package/skills/ai-delivery-manage-git/references/git-policy.md

@@ -0,0 +1,42 @@
+# AI Delivery Git Policy
+
+## Two Repository Contract
+
+The workspace root Git repository tracks `.workflow/`, project Skills, configuration, shared task shards, checkpoints, approvals, and manifests. Its `workflow/<workspace-id>` branch is shared workflow fact history. The direct child configured by `.workflow/config/workspace.yaml` is the only application code repository and owns every delivery branch, application `main`, and code Tag. The workflow repository ignores the exact code child path; the code repository does not ignore or track its parent.
+
+At version closeout, create the code Tag first, commit the final workflow manifest second, and create the workflow Tag third. A release-ready identity is valid only when the code Tag resolves to the candidate commit, the workflow Tag resolves to the workflow commit containing the manifest, and the manifest bytes match the recorded SHA-256.
+
+## Protected State
+
+Protect `main` and `line/*` from direct AI commits and history rewrites. Protect active `version/*` and `release/*` according to repository policy. Permit force-with-lease only on an unshared work or release-fix branch. Never discard uncommitted user changes.
+
+## Naming
+
+- `line/<product-id>`
+- `version/<version-id>-<slug>`
+- `work/<version-id>/<task-id>-<slug>`
+- `release/<release-id>-<slug>`
+- `release-fix/<release-id>/<defect-id>`
+- `hotfix/<hotfix-id>-<slug>`
+
+Use stable delivery IDs, not human names or dynamic AI roles.
+
+## Cumulative Version Policy
+
+Create every next planned version from the current product line head. Close a verified version by creating immutable `version-ready/<version-id>/rN` and fast-forwarding `line/<product-id>` to it. Historical version tags and manifests never change. A correction after closeout normally becomes the next planned version.
+
+`main` represents current successful production, while `line/<product-id>` represents the latest verified cumulative development. The line may advance through any number of release-ready versions without changing production.
+
+## Release Policy
+
+Create a release branch only after explicit user release intent. Build it from the exact target version-ready Tag. Verify every adjacent code and workflow commit edge from current production through the target; a direct production-to-target check does not prove the middle versions. Use intermediate versions for lineage and material closure, not repeated code merges.
+
+After successful production verification, fast-forward `main` to the deployed release commit. For same-version redeploy, record a new release ID and Tag while allowing `main` to remain unchanged.
+
+## Environment And Rollback Policy
+
+Do not create environment or rollback branches. Record environment deployments by release ID, commit, image digest, configuration baseline, migration set, and IaC state. Rollback deploys the previous compatible immutable image digest. Git history and Tags remain unchanged.
+
+## Hotfix Policy
+
+Create a hotfix from current production, verify and release it, then synchronize it into the cumulative product line. Any candidate not containing that commit becomes `stale` and cannot be selected for release.

package/skills/ai-delivery-manage-standards/SKILL.md

@@ -0,0 +1,44 @@
+---
+name: ai-delivery-manage-standards
+description: Capture, classify, approve, version, resolve, and apply durable project standards learned during human-AI delivery conversations. Use when a user establishes a recurring rule, asks to record or change a convention, requests applicable standards, proposes an exception, or when skills encounter conflicting guidance.
+---
+
+# Manage Standards
+
+Persist durable rules in the repository instead of relying on chat history. Do not silently turn a preference, suggestion, or one-time instruction into a standard.
+
+## Artifact Location
+
+Write approved standards, proposals, exceptions, and the standards index under `.workflow/standards/`. Pin adopted versions in `.workflow/delivery/standards-baseline.yaml`; version-scoped standards decisions may additionally be referenced from `.workflow/iterations/<iteration-id>/<node-id>/`.
+
+## Task State
+
+1. Invoke `$ai-delivery-checkpoint-task` before preflight to recover or initialize the task snapshot.
+2. Checkpoint after every meaningful artifact, gate, validation, merge, deployment action, or other external milestone, and before compaction or interruption.
+3. Before returning, finish the snapshot as `completed`, `blocked`, `failed`, or `interrupted`, with actual outputs, evidence, blockers, and one idempotent next action. A Hook event alone never proves completion.
+
+## Resolve Applicable Standards
+
+1. Read `AGENTS.md` and `.workflow/standards/index.yaml`.
+2. Select only approved standards matching the current stage, artifact type, technology, and scope.
+3. Load selected Markdown standards and return their IDs and versions.
+4. Apply precedence: system and tool constraints, approved scoped exceptions, more-specific approved project standards, then workflow defaults.
+5. Stop on unresolved conflicts at the same precedence.
+
+## Capture A Standard Candidate
+
+1. Detect durable normative language such as must, never, always, standardize, or use next time.
+2. Ask whether the rule is temporary, a durable standard, or a scoped exception when intent is unclear.
+3. Search for duplicate, overlapping, superseded, and conflicting standards.
+4. Draft the exact rule, scope, examples, enforcement, exception policy, version change, and impact.
+5. Show the proposed diff and affected artifacts or active iterations.
+6. Require human approval for creation, update, deprecation, or exception.
+7. Persist the approved standard, update the index, and mark impacted artifacts stale for revalidation.
+
+## Standard Shape
+
+Record ID, title, version, status, scope, effective date, superseded ID, rule, applicability, examples, automatic checks, exception conditions, and violation behavior. Keep one canonical source; Git history records prior text.
+
+Pin standards used by an iteration in `.workflow/delivery/standards-baseline.yaml` and record standards IDs and versions in every artifact manifest and release manifest.
+
+Read [standards-contract.md](references/standards-contract.md) and use `assets/standards-template/` for new project standards.

package/skills/ai-delivery-manage-standards/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "Manage Standards"
+  short_description: "Capture, approve, version, and resolve applicable standards"
+  default_prompt: "Use $ai-delivery-manage-standards to capture or resolve project standards."

package/skills/ai-delivery-manage-standards/assets/standards-template/standard.md

@@ -0,0 +1,25 @@
+---
+id: STD-AREA-001
+title: Replace With Standard Title
+version: 1.0.0
+status: draft
+scope: []
+effective_from: ""
+supersedes: null
+---
+
+# Rule
+
+# Applicability
+
+# Exclusions
+
+# Correct Examples
+
+# Incorrect Examples
+
+# Validation
+
+# Exceptions
+
+# Violation Behavior

package/skills/ai-delivery-manage-standards/references/standards-contract.md

@@ -0,0 +1,20 @@
+# Standards Contract
+
+## Registry
+
+`.workflow/standards/index.yaml` records standard ID, title, version, status, scope tags, effective date, superseded ID, and relative path.
+
+Use statuses `draft`, `approved`, `deprecated`, and `rejected`. Only approved standards bind work.
+
+## Standard Body
+
+Include rule, applicability, exclusions, correct and incorrect examples, automatic or manual validation, allowed exception conditions, and violation behavior (`stop`, `return`, or `warn`).
+
+## Governance
+
+- Require human approval for creation, revision, deprecation, and exception.
+- Use a new version for changed meaning.
+- Preserve one canonical body; use Git history instead of a duplicate changelog.
+- Resolve by system/tool constraints, approved scoped exception, more-specific approved project standard, then workflow default.
+- Stop on conflicting standards at equal precedence.
+- Pin applicable IDs and versions in every artifact and iteration standards baseline.

package/skills/ai-delivery-orchestrate/SKILL.md

@@ -0,0 +1,105 @@
+---
+name: ai-delivery-orchestrate
+description: Coordinate an initialized artifact-driven AI software delivery workflow from product discovery through a release-ready planned version, without implicitly publishing it. Use after project bootstrap, when creating or continuing an iteration, resolving a blocked handoff, running change-impact analysis, deciding which development stage may execute next, or routing an explicit release request to the separate release orchestrator.
+---
+
+# AI Delivery Orchestrator
+
+Coordinate state and handoffs. Do not produce specialist product, architecture, design, code, test, or deployment artifacts yourself.
+
+## Workspace Boundary
+
+Read `.workflow/config/workspace.yaml` before any Git or source operation. The workspace root is the workflow repository; the configured direct child is the only code repository. Workflow facts, approvals, manifests, and checkpoints are committed in the workflow repository. Source, tests, code branches, code Tags, and application commits exist only in the code repository. Every code reference in a workflow artifact must carry `repo_id`, `code_commit`, optional `code_tag`, `source_path`, and SHA-256.
+
+## Artifact Location
+
+Require every workflow document to be written under project `.workflow/`. Use `.workflow/delivery/` for workflow control, `.workflow/standards/` for standards, `.workflow/product/`, `.workflow/architecture/`, and `.workflow/experience/` for reusable baselines, and `.workflow/iterations/<iteration-id>/<node-id>/` for version-scoped node outputs. Keep source code, automated test source, repository configuration, and non-document build artifacts in their native locations.
+
+## Task State
+
+1. Invoke `$ai-delivery-bootstrap` in read-only inspect mode when the current session has not classified project state. Do this before checkpoint recovery because an empty or partially initialized project may not have a valid runtime store.
+2. After iteration planning, persist the ordered known-task plan and initialize every known task snapshot as `queued` with `sequence` and `depends_on`. When a node derives dynamic tasks, append and register the complete derived group before executing its first task.
+3. For a complete workflow, first read Bootstrap's `next_action_owner`. Only for `agent`, invoke `$ai-delivery-checkpoint-task recover --iteration-id <iteration-id>` before preflight. Recovery must rebuild local state from the latest Git-tracked shared checkpoint when local runtime is absent. Continue the returned `recommended_task_id`; never choose the next task from chat memory. For `user` or `external`, stop at the zero-mutation wait boundary in step 7.
+4. Activate the recommended task before project mutation. If no task is recommended, reconcile missing or unsatisfied task-plan entries before continuing.
+5. Checkpoint after every meaningful artifact, gate, validation, merge, deployment action, or other external milestone, and before compaction or interruption.
+6. Before returning, finish the snapshot as `completed`, `blocked`, `failed`, or `interrupted`, with actual outputs, evidence, blockers, and one idempotent next action. A Hook event alone never proves completion.
+7. Persist `next_action_owner` as `agent`, `user`, or `external`. A user- or external-owned next action is a zero-mutation wait state: on restart or a generic “continue”, return only the recorded question or wait condition. Do not recover, activate, checkpoint, mutate artifacts, or change Git state until the required input arrives and ownership is explicitly transferred to `agent` with a new idempotent next action through the task CLI.
+
+## Formal State
+
+1. Use `node .workflow/tools/state/state.mjs inspect` to read schema 2 formal state: independent `development_state` and `release_state` scopes, the top-level workflow audit revision, and the artifact-registry revision.
+2. Register every formal artifact with `artifact register`; change its lifecycle only with `artifact status`; create a new artifact ID and `--supersedes` instead of overwriting a registered version.
+3. Start development with `iteration-started`; start release only after explicit user intent with `release-started`. Record node, candidate, closeout, and archive changes with `transition`. Record human or contract Gates with `gate request` and `gate decide`.
+4. Pass the current stream revision through `--expected-revision` for every mutation. On a conflict, inspect again and reconcile; never retry blindly.
+5. Run `verify` before handoff, node completion, version closeout, and after recovery. Let the CLI enforce graph prerequisites, successful completion evidence, current-attempt mandatory Gates, and scope identity. Release nodes independently require verification at every release handoff. Stop on checksum, schema, audit, identity, or state-invariant failure.
+6. Never directly edit controlled formal state, shared task/checkpoint shards, or runtime task state. Treat global workflow and artifact indexes as deterministic views over authoritative shards where available. If either state script fails, repair the input or script problem rather than bypassing it.
+7. When the user clearly expresses a workflow improvement, invoke `$ai-delivery-evolve-workflow feedback record` and report the feedback ID. Do not save ordinary discussion, full conversation text, secrets, or AI reasoning. Evaluate pending evidence only after a task, version closeout, or explicit evolution review.
+
+## Preflight
+
+1. Invoke `$ai-delivery-bootstrap` when the project state has not been classified in the current session. Route empty, brownfield, interrupted, and inconsistent states there before normal orchestration.
+2. Locate the repository root and read `AGENTS.md` when present.
+3. Run `.workflow/tools/state/state.mjs inspect`; read `.workflow/delivery/project.yaml` for descriptive project metadata.
+4. Read `.workflow/standards/index.yaml`, resolve applicable approved standards with `$ai-delivery-manage-standards`, and pin their versions in `.workflow/delivery/standards-baseline.yaml`.
+5. Require project-scoped installation under `.agents/skills/ai-delivery-*`. Never install these skills into user-level `.codex/skills` or `.agents/skills` directories.
+6. Ensure `.workflow/delivery/runtime/`, `.workflow/delivery/runtime/active-task.json`, and `.workflow/delivery/runtime/backups/` are ignored by Git. Never ignore the complete `.workflow/` tree. Require normal Codex Hook trust review and never bypass it.
+7. Stop on malformed state, missing approved inputs, stale references, or conflicting standards. Use `$ai-delivery-validate-artifacts` before advancing.
+
+## Route The Workflow
+
+Use this first-release order:
+
+1. `$ai-delivery-bootstrap`: classify state, initialize missing project context, or route checkpoint recovery.
+2. `$ai-delivery-define-product`: discovery Gate A, then product baseline Gate B.
+3. `$ai-delivery-design-architecture`: initial mode and human approval of major decisions.
+4. Start `$ai-delivery-prepare-platform` as a parallel stream.
+5. `$ai-delivery-design-experience`: obtain one human authoring-tool selection per prototype member; create an executable low-fidelity prototype; pass human Gate `UX-LF`; define visual direction, design tokens, component states, and select a compatible UI framework; pass human Gate `UX-VS`; create a runnable formal UI; pass human Gate `UX-UI`; record every review adjustment and upstream impact.
+6. `$ai-delivery-define-product` in prototype-reconciliation mode: after all formal UI candidates are approved, reconcile the complete adjustment set bidirectionally with product requirements through `product-prototype-reconciliation.yaml`. Rebaseline and repeat affected experience Gates until the decision is `aligned`.
+7. `$ai-delivery-design-architecture`: reconcile mode, prototype architecture receipt, `ready-for-development` experience changes, and final architecture baseline.
+8. `$ai-delivery-plan-iteration`.
+9. `$ai-delivery-design-tests`: prototype test receipt and public test contract.
+10. `$ai-delivery-develop-iteration`, including independent change review.
+11. Join the candidate and delivery-platform streams in a reproducible test environment.
+12. `$ai-delivery-verify-candidate` with `scope: iteration`; route failures upstream.
+13. `$ai-delivery-close-version`; create the immutable `version-ready` tag, advance `line/<product-id>`, mark the version `release-ready`, move closed shared task/checkpoint shards to `.workflow/control/archives/versions/<version-id>/`, and remove them from active recovery collections.
+14. Stop. Continue the next cumulative planned version from the latest line head, or wait for explicit user intent.
+
+At every task and version safe point, route eligible feedback and trial observations through `$ai-delivery-evolve-workflow`. Extension behavior begins with the next task or version and never mutates an in-progress execution.
+
+Never start release preparation, production approval, deployment, or production verification merely because a version is complete. When the user explicitly asks to release or deploy selected completed versions, route to `$ai-delivery-orchestrate-release`.
+
+For later iterations, start from the latest `line/<product-id>` head, run change-impact analysis, and revisit only affected baselines. Always run planning, test design, implementation or platform changes, candidate verification, and version closeout. Release work is a separate user-triggered workflow.
+
+## Enforce Human Gates
+
+Pause for humans at:
+
+- discovery Gate A and product baseline Gate B;
+- major architecture decisions;
+- each prototype member's authoring-tool selection before prototype authoring;
+- each visual or interactive prototype member's `UX-LF`, `UX-VS`, and `UX-UI` decisions, repeated until the latest round is approved and every comment is terminal;
+- production deployment approval;
+- every proposed standard creation, update, deprecation, or exception.
+
+Allow downstream contract validation instead of human approval at ordinary intermediate handoffs.
+
+## Maintain State
+
+- Give every project, iteration, artifact, feature, story, acceptance criterion, slice, task, test, defect, release item, and deployment a stable ID.
+- Record artifact input IDs and versions; never infer dependencies from filenames.
+- Treat approved baselines and release versions as immutable. Create a new version for changes.
+- Carry the same immutable UI handoff, aligned product reconciliation, experience-change set, prototype-set identity/checksum and relevant member identities, source revisions, review-bundle checksums, tool-selection checksums, page/canvas/file catalog checksums, review/adjustment checksums, and impact-assessment checksums through architecture, planning, test design, development, and verification.
+- Mark downstream artifacts stale after an upstream change and route only the impacted work.
+- Record the standards baseline used by every artifact.
+- Keep one production release transition locked at a time while allowing later cumulative iteration work in parallel.
+
+## Handle Failures
+
+Use `$ai-delivery-triage-failure` to route evidence to the owning stage. Never let a validator silently repair the artifact it validates. A corrected artifact must return through its producer and downstream impact checks.
+
+## Report To The User
+
+For status requests, show the current iteration, active and blocked development/release nodes, missing inputs, pending human gates, latest immutable candidate, production version, latest cumulative line version, release-ready version count, and one recommended next action. Do not recommend publishing unless the user has expressed release intent.
+
+Read [workflow-model.md](references/workflow-model.md) for the state graph, gate rules, and artifact lifecycle.
+Read [formal-state-contract.md](references/formal-state-contract.md) before mutating formal state.

package/skills/ai-delivery-orchestrate/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "AI Delivery Orchestrator"
+  short_description: "Coordinate AI delivery stages, gates, artifacts, and routing"
+  default_prompt: "Use $ai-delivery-orchestrate to start or continue the current workflow using the configured workflow and code repositories."

package/skills/ai-delivery-orchestrate/assets/project-template/.codex/config.toml

@@ -0,0 +1,92 @@
+[features]
+hooks = true
+
+[[hooks.SessionStart]]
+matcher = ""
+[[hooks.SessionStart.hooks]]
+type = "command"
+command = "node .workflow/tools/hooks/hook-event.mjs"
+commandWindows = "node .workflow/tools/hooks/hook-event.mjs"
+timeout = 5
+async = false
+
+[[hooks.UserPromptSubmit]]
+matcher = ""
+[[hooks.UserPromptSubmit.hooks]]
+type = "command"
+command = "node .workflow/tools/hooks/hook-event.mjs"
+commandWindows = "node .workflow/tools/hooks/hook-event.mjs"
+timeout = 5
+async = false
+
+[[hooks.PreToolUse]]
+matcher = ""
+[[hooks.PreToolUse.hooks]]
+type = "command"
+command = "node .workflow/tools/hooks/hook-event.mjs"
+commandWindows = "node .workflow/tools/hooks/hook-event.mjs"
+timeout = 5
+async = false
+
+[[hooks.PermissionRequest]]
+matcher = ""
+[[hooks.PermissionRequest.hooks]]
+type = "command"
+command = "node .workflow/tools/hooks/hook-event.mjs"
+commandWindows = "node .workflow/tools/hooks/hook-event.mjs"
+timeout = 5
+async = false
+
+[[hooks.PostToolUse]]
+matcher = ""
+[[hooks.PostToolUse.hooks]]
+type = "command"
+command = "node .workflow/tools/hooks/hook-event.mjs"
+commandWindows = "node .workflow/tools/hooks/hook-event.mjs"
+timeout = 5
+async = false
+
+[[hooks.PreCompact]]
+matcher = ""
+[[hooks.PreCompact.hooks]]
+type = "command"
+command = "node .workflow/tools/hooks/hook-event.mjs"
+commandWindows = "node .workflow/tools/hooks/hook-event.mjs"
+timeout = 5
+async = false
+
+[[hooks.PostCompact]]
+matcher = ""
+[[hooks.PostCompact.hooks]]
+type = "command"
+command = "node .workflow/tools/hooks/hook-event.mjs"
+commandWindows = "node .workflow/tools/hooks/hook-event.mjs"
+timeout = 5
+async = false
+
+[[hooks.SubagentStart]]
+matcher = ""
+[[hooks.SubagentStart.hooks]]
+type = "command"
+command = "node .workflow/tools/hooks/hook-event.mjs"
+commandWindows = "node .workflow/tools/hooks/hook-event.mjs"
+timeout = 5
+async = false
+
+[[hooks.SubagentStop]]
+matcher = ""
+[[hooks.SubagentStop.hooks]]
+type = "command"
+command = "node .workflow/tools/hooks/hook-event.mjs"
+commandWindows = "node .workflow/tools/hooks/hook-event.mjs"
+timeout = 5
+async = false
+
+[[hooks.Stop]]
+matcher = ""
+[[hooks.Stop.hooks]]
+type = "command"
+command = "node .workflow/tools/hooks/hook-event.mjs"
+commandWindows = "node .workflow/tools/hooks/hook-event.mjs"
+timeout = 5
+async = false

package/skills/ai-delivery-orchestrate/assets/project-template/.gitattributes

@@ -0,0 +1,6 @@
+/.workflow/** text=auto eol=lf
+/.agents/skills/ai-delivery-*/** text=auto eol=lf
+/.codex/config.toml text eol=lf
+/AGENTS.md text eol=lf
+/.gitignore text eol=lf
+/.gitattributes text eol=lf

package/skills/ai-delivery-orchestrate/assets/project-template/.workflow/delivery/artifact-registry.yaml

@@ -0,0 +1,3 @@
+schema_version: 1
+revision: 0
+artifacts: []

package/skills/ai-delivery-orchestrate/assets/project-template/.workflow/delivery/project.yaml

@@ -0,0 +1,6 @@
+project_id: PROJECT-0001
+name: ""
+status: active
+created_at: ""
+current_iteration_id: INIT-0001
+production_release_id: null

package/skills/ai-delivery-orchestrate/assets/project-template/.workflow/delivery/standards-baseline.yaml

@@ -0,0 +1,8 @@
+iteration_id: INIT-0001
+standards:
+  - id: STD-DOC-LANG-001
+    version: 1.0.0
+  - id: STD-ARTIFACT-PATH-001
+    version: 1.0.0
+  - id: STD-TEST-LOCATION-001
+    version: 1.1.0

package/skills/ai-delivery-orchestrate/assets/project-template/.workflow/delivery/workflow-state.yaml

@@ -0,0 +1,34 @@
+schema_version: 2
+revision: 0
+project_id: PROJECT-0001
+development_state:
+  scope_id: INIT-0001
+  revision: 0
+  active_nodes: []
+  blocked_nodes: []
+  completed_nodes: []
+  pending_gates: []
+  gate_decisions: []
+  node_attempts: {}
+  latest_candidate_id: null
+  latest_release_id: null
+  updated_at: ""
+  last_transition: null
+release_state:
+  scope_id: null
+  revision: 0
+  active_nodes: []
+  blocked_nodes: []
+  completed_nodes: []
+  pending_gates: []
+  gate_decisions: []
+  node_attempts: {}
+  latest_candidate_id: null
+  latest_release_id: null
+  updated_at: ""
+  last_transition: null
+latest_line_version_id: null
+production_version_id: null
+production_release_id: null
+updated_at: ""
+last_transition: null

package/skills/ai-delivery-orchestrate/assets/project-template/.workflow/evolution/index.yaml

@@ -0,0 +1,7 @@
+schema_version: 1
+revision: 0
+feedback: []
+proposals: []
+extensions: []
+decisions: []
+updated_at: null