engineering-process 1.2.6__tar.gz → 2.0.0__tar.gz

{engineering_process-1.2.6/engineering_process.egg-info → engineering_process-2.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: engineering-process
-Version: 1.2.6
+Version: 2.0.0
 Summary: A small agent-neutral engineering lifecycle with managed adoption
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/phuongnse/engineering-process
@@ -33,11 +33,27 @@ Portable skills explain what to do. processctl owns state transitions and curren
 evidence. Each consumer owns its product rules, exact commands, merge policy, and
 release decisions.
 
+Start delivery work with [deliver-change](process_assets/skills/deliver-change/SKILL.md).
+It selects the current phase from lifecycle state; callers do not select a phase skill:
+
+    deliver-change
+      change-start -> change-plan -> change-implement -> change-verify
+        -> change-review -> change-complete
+
+[process-improve](process_assets/skills/process-improve/SKILL.md) handles a reusable
+process problem, then returns delivery to the same lifecycle.
+[production-engineering](process_assets/skills/production-engineering/SKILL.md) supplies
+the invariant floor consulted from planning through independent review. Both are
+reachable specializations; neither advances lifecycle state. `change-complete` calls
+the existing `processctl change finish` command.
+
+For migration from the previous skill identifiers, see [Versioning](VERSIONING.md#skill-namespace-migration).
+
 ## Architecture
 
 The distribution has four live parts:
 
-1. Managed skills under process_assets/skills, all reachable from run-change.
+1. Managed skills under process_assets/skills, all reachable from deliver-change.
 2. One processctl state machine under engineering_process/lifecycle.py.
 3. JSON Schemas that are loaded directly by the runtime.
 4. One adoption transaction that synchronizes managed skills and configuration from
@@ -175,7 +191,7 @@ This assessment is not a production certificate. Production still requires the
 consumer's immutable readiness pack, every required capability in `enforced` state,
 fresh consumer-owned verification on the exact candidate, and independent review.
 
-For each ordinary change, `run-change` first surfaces this readiness view. The accepted
+For each ordinary change, `deliver-change` first surfaces this readiness view. The accepted
 request and consumer rules determine which capabilities are affected. Every change
 retains the project's baseline `requiredProfiles`; start and plan add any conditional
 evidence profiles needed by affected capabilities and include a planned gap only when
@@ -184,7 +200,7 @@ floor. A planned-to-enforced promotion is a reviewed consumer source diff with f
 evidence. Unrelated planned gaps remain visible but do not block development, and no
 skill chooses product priorities or changes readiness automatically.
 
-When a consumer incident exposes a reusable process gap, `improve-process` first keeps
+When a consumer incident exposes a reusable process gap, `process-improve` first keeps
 the consumer safe, then prepares a sanitized GitHub issue draft from that checkout.
 It deduplicates by consumer/process-version/invariant, requires owner authorization
 before `gh issue create`, and uses an accepted issue as the later process change source
@@ -352,7 +368,7 @@ URL; without it, the review remains pending. Earlier plan and review documents r
 readable, and their runs remain registrable or finishable with the version selected by
 the authority that started the relevant phase.
 
-The [finding priority definitions](process_assets/skills/review-change/SKILL.md#finding-priority)
+The [finding priority definitions](process_assets/skills/change-review/SKILL.md#finding-priority)
 are the canonical P0-P3 impact convention for this process, including examples and
 their relationship to blocking decisions.
 

{engineering_process-1.2.6 → engineering_process-2.0.0}/README.md

@@ -9,11 +9,27 @@ Portable skills explain what to do. processctl owns state transitions and curren
 evidence. Each consumer owns its product rules, exact commands, merge policy, and
 release decisions.
 
+Start delivery work with [deliver-change](process_assets/skills/deliver-change/SKILL.md).
+It selects the current phase from lifecycle state; callers do not select a phase skill:
+
+    deliver-change
+      change-start -> change-plan -> change-implement -> change-verify
+        -> change-review -> change-complete
+
+[process-improve](process_assets/skills/process-improve/SKILL.md) handles a reusable
+process problem, then returns delivery to the same lifecycle.
+[production-engineering](process_assets/skills/production-engineering/SKILL.md) supplies
+the invariant floor consulted from planning through independent review. Both are
+reachable specializations; neither advances lifecycle state. `change-complete` calls
+the existing `processctl change finish` command.
+
+For migration from the previous skill identifiers, see [Versioning](VERSIONING.md#skill-namespace-migration).
+
 ## Architecture
 
 The distribution has four live parts:
 
-1. Managed skills under process_assets/skills, all reachable from run-change.
+1. Managed skills under process_assets/skills, all reachable from deliver-change.
 2. One processctl state machine under engineering_process/lifecycle.py.
 3. JSON Schemas that are loaded directly by the runtime.
 4. One adoption transaction that synchronizes managed skills and configuration from
@@ -151,7 +167,7 @@ This assessment is not a production certificate. Production still requires the
 consumer's immutable readiness pack, every required capability in `enforced` state,
 fresh consumer-owned verification on the exact candidate, and independent review.
 
-For each ordinary change, `run-change` first surfaces this readiness view. The accepted
+For each ordinary change, `deliver-change` first surfaces this readiness view. The accepted
 request and consumer rules determine which capabilities are affected. Every change
 retains the project's baseline `requiredProfiles`; start and plan add any conditional
 evidence profiles needed by affected capabilities and include a planned gap only when
@@ -160,7 +176,7 @@ floor. A planned-to-enforced promotion is a reviewed consumer source diff with f
 evidence. Unrelated planned gaps remain visible but do not block development, and no
 skill chooses product priorities or changes readiness automatically.
 
-When a consumer incident exposes a reusable process gap, `improve-process` first keeps
+When a consumer incident exposes a reusable process gap, `process-improve` first keeps
 the consumer safe, then prepares a sanitized GitHub issue draft from that checkout.
 It deduplicates by consumer/process-version/invariant, requires owner authorization
 before `gh issue create`, and uses an accepted issue as the later process change source
@@ -328,7 +344,7 @@ URL; without it, the review remains pending. Earlier plan and review documents r
 readable, and their runs remain registrable or finishable with the version selected by
 the authority that started the relevant phase.
 
-The [finding priority definitions](process_assets/skills/review-change/SKILL.md#finding-priority)
+The [finding priority definitions](process_assets/skills/change-review/SKILL.md#finding-priority)
 are the canonical P0-P3 impact convention for this process, including examples and
 their relationship to blocking decisions.
 

{engineering_process-1.2.6 → engineering_process-2.0.0}/engineering_process/__init__.py

@@ -1,3 +1,3 @@
 """Agent-neutral engineering process."""
 
-VERSION = "1.2.6"
+VERSION = "2.0.0"

{engineering_process-1.2.6 → engineering_process-2.0.0}/engineering_process/skills.py

@@ -90,6 +90,21 @@ def validate_skills(
     graph = load_and_validate(
         graph_path, "process-graph", schema_root=schemas_root(process_root)
     )
+    owners = {state["id"]: state["ownerSkill"] for state in graph["states"]}
+    if len(owners) != len(graph["states"]):
+        raise ProcessError("process graph state ids must be unique")
+    for state in graph["states"]:
+        for transition in state["transitions"]:
+            destination = transition["nextState"]
+            skill = transition["nextSkill"]
+            if (destination is None) != (skill is None):
+                raise ProcessError("process graph terminal transitions must have both targets null")
+            if destination is not None and destination not in owners:
+                raise ProcessError(f"process graph references missing state: {destination}")
+            if skill is not None and skill not in names:
+                raise ProcessError(
+                    f"process graph transition from {state['id']} references missing skill: {skill}"
+                )
     routed = {graph["entrySkill"]}
     routed.update(state["ownerSkill"] for state in graph["states"])
     routed.update(graph.get("specializations", {}).values())

{engineering_process-1.2.6 → engineering_process-2.0.0/engineering_process.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: engineering-process
-Version: 1.2.6
+Version: 2.0.0
 Summary: A small agent-neutral engineering lifecycle with managed adoption
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/phuongnse/engineering-process
@@ -33,11 +33,27 @@ Portable skills explain what to do. processctl owns state transitions and curren
 evidence. Each consumer owns its product rules, exact commands, merge policy, and
 release decisions.
 
+Start delivery work with [deliver-change](process_assets/skills/deliver-change/SKILL.md).
+It selects the current phase from lifecycle state; callers do not select a phase skill:
+
+    deliver-change
+      change-start -> change-plan -> change-implement -> change-verify
+        -> change-review -> change-complete
+
+[process-improve](process_assets/skills/process-improve/SKILL.md) handles a reusable
+process problem, then returns delivery to the same lifecycle.
+[production-engineering](process_assets/skills/production-engineering/SKILL.md) supplies
+the invariant floor consulted from planning through independent review. Both are
+reachable specializations; neither advances lifecycle state. `change-complete` calls
+the existing `processctl change finish` command.
+
+For migration from the previous skill identifiers, see [Versioning](VERSIONING.md#skill-namespace-migration).
+
 ## Architecture
 
 The distribution has four live parts:
 
-1. Managed skills under process_assets/skills, all reachable from run-change.
+1. Managed skills under process_assets/skills, all reachable from deliver-change.
 2. One processctl state machine under engineering_process/lifecycle.py.
 3. JSON Schemas that are loaded directly by the runtime.
 4. One adoption transaction that synchronizes managed skills and configuration from
@@ -175,7 +191,7 @@ This assessment is not a production certificate. Production still requires the
 consumer's immutable readiness pack, every required capability in `enforced` state,
 fresh consumer-owned verification on the exact candidate, and independent review.
 
-For each ordinary change, `run-change` first surfaces this readiness view. The accepted
+For each ordinary change, `deliver-change` first surfaces this readiness view. The accepted
 request and consumer rules determine which capabilities are affected. Every change
 retains the project's baseline `requiredProfiles`; start and plan add any conditional
 evidence profiles needed by affected capabilities and include a planned gap only when
@@ -184,7 +200,7 @@ floor. A planned-to-enforced promotion is a reviewed consumer source diff with f
 evidence. Unrelated planned gaps remain visible but do not block development, and no
 skill chooses product priorities or changes readiness automatically.
 
-When a consumer incident exposes a reusable process gap, `improve-process` first keeps
+When a consumer incident exposes a reusable process gap, `process-improve` first keeps
 the consumer safe, then prepares a sanitized GitHub issue draft from that checkout.
 It deduplicates by consumer/process-version/invariant, requires owner authorization
 before `gh issue create`, and uses an accepted issue as the later process change source
@@ -352,7 +368,7 @@ URL; without it, the review remains pending. Earlier plan and review documents r
 readable, and their runs remain registrable or finishable with the version selected by
 the authority that started the relevant phase.
 
-The [finding priority definitions](process_assets/skills/review-change/SKILL.md#finding-priority)
+The [finding priority definitions](process_assets/skills/change-review/SKILL.md#finding-priority)
 are the canonical P0-P3 impact convention for this process, including examples and
 their relationship to blocking decisions.
 

{engineering_process-1.2.6 → engineering_process-2.0.0}/engineering_process.egg-info/SOURCES.txt

@@ -31,16 +31,16 @@ engineering_process.egg-info/dependency_links.txt
 engineering_process.egg-info/entry_points.txt
 engineering_process.egg-info/requires.txt
 engineering_process.egg-info/top_level.txt
-process_assets/skills/finish-change/SKILL.md
-process_assets/skills/implement-change/SKILL.md
-process_assets/skills/improve-process/SKILL.md
-process_assets/skills/plan-change/SKILL.md
+process_assets/skills/change-complete/SKILL.md
+process_assets/skills/change-implement/SKILL.md
+process_assets/skills/change-plan/SKILL.md
+process_assets/skills/change-review/SKILL.md
+process_assets/skills/change-start/SKILL.md
+process_assets/skills/change-verify/SKILL.md
+process_assets/skills/deliver-change/SKILL.md
+process_assets/skills/process-improve/SKILL.md
 process_assets/skills/production-engineering/SKILL.md
 process_assets/skills/production-engineering/invariants.json
-process_assets/skills/review-change/SKILL.md
-process_assets/skills/run-change/SKILL.md
-process_assets/skills/start-change/SKILL.md
-process_assets/skills/verify-change/SKILL.md
 schemas/change.schema.json
 schemas/plan.schema.json
 schemas/process-graph.schema.json

{engineering_process-1.2.6 → engineering_process-2.0.0}/process-graph.json

@@ -1,83 +1,83 @@
 {
   "schemaVersion": 2,
-  "entrySkill": "run-change",
+  "entrySkill": "deliver-change",
   "specializations": {
-    "processChange": "improve-process",
+    "processChange": "process-improve",
     "productionEngineering": "production-engineering"
   },
   "states": [
     {
       "id": "unregistered",
-      "ownerSkill": "start-change",
+      "ownerSkill": "change-start",
       "commands": ["change start"],
       "transitions": [
-        {"result": "success", "nextState": "specified", "nextSkill": "plan-change"}
+        {"result": "success", "nextState": "specified", "nextSkill": "change-plan"}
       ]
     },
     {
       "id": "specified",
-      "ownerSkill": "plan-change",
+      "ownerSkill": "change-plan",
       "commands": ["change plan"],
       "transitions": [
-        {"result": "success", "nextState": "planned", "nextSkill": "implement-change"}
+        {"result": "success", "nextState": "planned", "nextSkill": "change-implement"}
       ]
     },
     {
       "id": "planned",
-      "ownerSkill": "implement-change",
+      "ownerSkill": "change-implement",
       "commands": ["change implement"],
       "transitions": [
-        {"result": "success", "nextState": "implementing", "nextSkill": "verify-change"}
+        {"result": "success", "nextState": "implementing", "nextSkill": "change-verify"}
       ]
     },
     {
       "id": "implementing",
-      "ownerSkill": "verify-change",
+      "ownerSkill": "change-verify",
       "commands": ["change implement", "change verify"],
       "transitions": [
-        {"result": "profile-passed", "nextState": "implementing", "nextSkill": "verify-change"},
-        {"result": "all-passed", "nextState": "verified", "nextSkill": "review-change"}
+        {"result": "profile-passed", "nextState": "implementing", "nextSkill": "change-verify"},
+        {"result": "all-passed", "nextState": "verified", "nextSkill": "change-review"}
       ]
     },
     {
       "id": "verified",
-      "ownerSkill": "review-change",
+      "ownerSkill": "change-review",
       "commands": ["change implement", "change review start"],
       "transitions": [
-        {"result": "assigned", "nextState": "review-pending", "nextSkill": "review-change"},
-        {"result": "source-changed", "nextState": "implementing", "nextSkill": "implement-change"}
+        {"result": "assigned", "nextState": "review-pending", "nextSkill": "change-review"},
+        {"result": "source-changed", "nextState": "implementing", "nextSkill": "change-implement"}
       ]
     },
     {
       "id": "review-pending",
-      "ownerSkill": "review-change",
+      "ownerSkill": "change-review",
       "commands": ["change implement", "change review submit"],
       "transitions": [
-        {"result": "approved", "nextState": "approved", "nextSkill": "finish-change"},
-        {"result": "changes-requested", "nextState": "changes-requested", "nextSkill": "implement-change"},
-        {"result": "source-changed", "nextState": "implementing", "nextSkill": "implement-change"}
+        {"result": "approved", "nextState": "approved", "nextSkill": "change-complete"},
+        {"result": "changes-requested", "nextState": "changes-requested", "nextSkill": "change-implement"},
+        {"result": "source-changed", "nextState": "implementing", "nextSkill": "change-implement"}
       ]
     },
     {
       "id": "changes-requested",
-      "ownerSkill": "implement-change",
+      "ownerSkill": "change-implement",
       "commands": ["change implement"],
       "transitions": [
-        {"result": "success", "nextState": "implementing", "nextSkill": "verify-change"}
+        {"result": "success", "nextState": "implementing", "nextSkill": "change-verify"}
       ]
     },
     {
       "id": "approved",
-      "ownerSkill": "finish-change",
+      "ownerSkill": "change-complete",
       "commands": ["change finish", "change implement"],
       "transitions": [
         {"result": "success", "nextState": null, "nextSkill": null},
-        {"result": "source-changed", "nextState": "implementing", "nextSkill": "implement-change"}
+        {"result": "source-changed", "nextState": "implementing", "nextSkill": "change-implement"}
       ]
     },
     {
       "id": "blocked",
-      "ownerSkill": "run-change",
+      "ownerSkill": "deliver-change",
       "commands": [],
       "transitions": []
     }

{engineering_process-1.2.6/process_assets/skills/finish-change → engineering_process-2.0.0/process_assets/skills/change-complete}/SKILL.md

@@ -1,9 +1,9 @@
 ---
-name: finish-change
-description: Complete an approved change only while its verification and independent review still match the current repository snapshot.
+name: change-complete
+description: Complete an approved change when routed by deliver-change, only while verification and independent review still match the repository snapshot.
 ---
 
-# Finish a change
+# Complete a change
 
 Confirm the lifecycle is approved, every required profile passed, every blocking
 finding is closed, every non-blocking finding has its required disposition, and the
@@ -11,7 +11,8 @@ repository still matches the reviewed snapshot. Then run:
 
     processctl change finish --change-id ID --actor ACTOR --context CONTEXT
 
-The command writes one bounded completion receipt and marks the run completed.
+The existing `change finish` CLI operation writes one bounded completion receipt and
+marks the run completed.
 Completion does not itself grant merge, deployment, or release authority; those
 remain project-owned operations. Never report completion from prose alone.
 

{engineering_process-1.2.6/process_assets/skills/implement-change → engineering_process-2.0.0/process_assets/skills/change-implement}/SKILL.md

@@ -1,6 +1,6 @@
 ---
-name: implement-change
-description: Implement the accepted plan or resolve blocking review findings without changing the contract implicitly.
+name: change-implement
+description: Implement the accepted plan or resolve blocking review findings when routed by deliver-change, without changing the contract implicitly.
 ---
 
 # Implement a change
@@ -29,4 +29,4 @@ gaps merely because they are listed.
 
 When evidence exposes a contract gap, stop and ask the project owner to supersede the
 contract. Do not make review prose into new scope. When implementation is ready,
-route to **verify-change**.
+route to **change-verify**.

{engineering_process-1.2.6/process_assets/skills/plan-change → engineering_process-2.0.0/process_assets/skills/change-plan}/SKILL.md

@@ -1,6 +1,6 @@
 ---
-name: plan-change
-description: Produce the smallest implementation plan that covers every accepted outcome and its verification boundary.
+name: change-plan
+description: Plan the registered change and its verification boundary when deliver-change routes a specified change.
 ---
 
 # Plan a change

{engineering_process-1.2.6/process_assets/skills/review-change → engineering_process-2.0.0/process_assets/skills/change-review}/SKILL.md

@@ -1,15 +1,24 @@
 ---
-name: review-change
-description: Review the exact verified snapshot from an actor and context independent of its implementation.
+name: change-review
+description: Review the exact verified snapshot from an independent actor and context when routed by deliver-change.
 ---
 
 # Review a change
 
 The reviewer must not share either actor identity or execution context with an
-implementer in the current cycle. Start the assignment:
+implementer in the current cycle. Read `processctl change status --change-id ID`.
+When the phase is `verified`, start the assignment:
 
     processctl change review start --change-id ID --actor REVIEWER --context REVIEW_CONTEXT
 
+When the phase is `review-pending`, resume the existing assignment; do not run
+`change review start` again. Read `.process/runs/ID/run.json` for its `cycle` and
+`reviewAssignment`, including the assigned reviewer, checkpoint, and
+`reportSchemaVersion`. Continue with the assigned independent actor/context and the
+existing report path, `.process/runs/ID/review-CYCLE.json`. If that reviewer is
+unavailable, report the pending assignment as a blocker; never impersonate its
+identity or create a replacement assignment from another context.
+
 Review the accepted contract, plan, complete diff, focused tests, and verification
 evidence. The first pass is comprehensive within that frozen contract. Every finding
 maps to one accepted criterion and records priority, origin, severity, and location.
@@ -41,7 +50,7 @@ consider consumer evidence that the lifecycle cannot observe. Every schema-versi
 report classifies `processImprovement` as `none`, `consumer-specific`, or
 `shared-process` and gives a concrete rationale. Consumer-specific behavior stays in
 the consumer. For `shared-process`, keep the assignment `review-pending` and route the
-candidate through **improve-process**. Submit only after an existing or owner-authorized
+candidate through **process-improve**. Submit only after an existing or owner-authorized
 issue supplies the stable HTTPS `recordUrl`; the review itself remains read-only.
 
 Read the consumer readiness result and repository rules. Check the complete diff for
@@ -56,8 +65,8 @@ Validate and submit the report:
     processctl contract validate --kind review REPORT_PATH
     processctl change review submit --change-id ID --review REPORT_PATH
 
-Review is read-only. Requested changes route back to **implement-change**; approval
-routes to **finish-change**. Keep the same independent reviewer for corrections.
+Review is read-only. Requested changes route back to **change-implement**; approval
+routes to **change-complete**. Keep the same independent reviewer for corrections.
 Follow-up scope is only carried findings, remediation diffs, and regressions against
 the frozen contract. A new blocker must be either remediation-caused or a P0/P1 late
 violation with a rationale. After two correction cycles, another changes-requested

{engineering_process-1.2.6/process_assets/skills/start-change → engineering_process-2.0.0/process_assets/skills/change-start}/SKILL.md

@@ -1,6 +1,6 @@
 ---
-name: start-change
-description: Turn an accepted request into a bounded change contract before planning or implementation begins.
+name: change-start
+description: Turn an accepted request into a bounded change contract when deliver-change routes a new change to lifecycle start.
 ---
 
 # Start a change

{engineering_process-1.2.6/process_assets/skills/verify-change → engineering_process-2.0.0/process_assets/skills/change-verify}/SKILL.md

@@ -1,6 +1,6 @@
 ---
-name: verify-change
-description: Run the project-owned verification profiles and bind their results to one unchanged repository snapshot.
+name: change-verify
+description: Run the project-owned verification profiles on one unchanged repository snapshot when routed by deliver-change.
 ---
 
 # Verify a change
@@ -23,4 +23,4 @@ planned capability whose gap remains open. A readiness promotion is valid only w
 all evidence named by that capability passes on this same snapshot.
 
 When all required profiles pass on the same snapshot, the lifecycle becomes verified;
-route to **review-change**.
+route to **change-review**.

{engineering_process-1.2.6/process_assets/skills/run-change → engineering_process-2.0.0/process_assets/skills/deliver-change}/SKILL.md

@@ -1,9 +1,9 @@
 ---
-name: run-change
-description: Route a non-trivial repository change through the complete engineering process from an accepted contract to independently reviewed completion.
+name: deliver-change
+description: Drive a repository change through the governed engineering lifecycle, from an accepted contract to independently reviewed completion.
 ---
 
-# Run a change
+# Deliver a change
 
 Use this as the only entry point for delivery work. Run `processctl project validate
 --json` first. When readiness is present, report its stage, immutable pack versions,
@@ -11,21 +11,22 @@ enforced floor, and planned gaps. Planned gaps guide future work but do not beco
 scope of the current change unless the accepted request selects one; never choose the
 product roadmap autonomously.
 
-Inspect processctl change status when a change already exists, then route exactly one
-current phase:
-
-1. No run: use **start-change**.
-2. specified: use **plan-change**.
-3. planned or changes-requested: use **implement-change**.
-4. implementing: use **verify-change**.
-5. verified or review-pending: use **review-change**; if the repository changed after
-   evidence was recorded, use **implement-change** to open a new cycle.
-6. approved: use **finish-change**; a later repository change also reopens through
-   **implement-change**.
+The six **change-*** skills are lifecycle routes selected here. Inspect processctl
+change status when a change already exists, then route exactly one current phase:
+
+1. No run: use **change-start**.
+2. specified: use **change-plan**.
+3. planned or changes-requested: use **change-implement**.
+4. implementing: use **change-verify**.
+5. verified or review-pending: use **change-review**, resuming the existing assignment
+   when review is pending; if the repository changed after evidence was recorded,
+   use **change-implement** to open a new cycle.
+6. approved: use **change-complete**; a later repository change also reopens through
+   **change-implement**.
 7. blocked: stop. The current contract cannot merge; the owner may narrow or
    supersede it, but no correction-limit stop can waive independent review.
 
-When changing this process itself, first use **improve-process** to prove the request
+When changing this process itself, first use **process-improve** to prove the request
 came from a real consumer incident or need; the change still follows the same six
 phases afterward.
 

{engineering_process-1.2.6/process_assets/skills/improve-process → engineering_process-2.0.0/process_assets/skills/process-improve}/SKILL.md

@@ -1,5 +1,5 @@
 ---
-name: improve-process
+name: process-improve
 description: Change the shared process only in response to evidence from a real consumer and prefer removing complexity over adding governance.
 ---
 
@@ -68,7 +68,7 @@ Find the smallest reusable correction. Prefer, in order:
 4. add a new gate only when the consumer evidence proves the other options cannot
    protect the required invariant.
 
-Use **run-change** for the actual work and require the same independent final review
+Use **deliver-change** for the actual work and require the same independent final review
 as any consumer change. Track cross-repository discussion in ordinary issues or pull
 requests; do not create a second lifecycle or evidence federation. The process never
 self-publishes or self-merges: the owner retains release and adoption authority, and

{engineering_process-1.2.6 → engineering_process-2.0.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "engineering-process"
-version = "1.2.6"
+version = "2.0.0"
 description = "A small agent-neutral engineering lifecycle with managed adoption"
 readme = "README.md"
 license = "MIT"
@@ -60,15 +60,15 @@ dev = {file = ["engineering_process/requirements-dev.txt"]}
   "schemas/review.schema.json",
   "schemas/run.schema.json",
 ]
-"share/engineering-process/skills/finish-change" = ["process_assets/skills/finish-change/SKILL.md"]
-"share/engineering-process/skills/implement-change" = ["process_assets/skills/implement-change/SKILL.md"]
-"share/engineering-process/skills/improve-process" = ["process_assets/skills/improve-process/SKILL.md"]
-"share/engineering-process/skills/plan-change" = ["process_assets/skills/plan-change/SKILL.md"]
+"share/engineering-process/skills/change-complete" = ["process_assets/skills/change-complete/SKILL.md"]
+"share/engineering-process/skills/change-implement" = ["process_assets/skills/change-implement/SKILL.md"]
+"share/engineering-process/skills/change-plan" = ["process_assets/skills/change-plan/SKILL.md"]
+"share/engineering-process/skills/change-review" = ["process_assets/skills/change-review/SKILL.md"]
+"share/engineering-process/skills/change-start" = ["process_assets/skills/change-start/SKILL.md"]
+"share/engineering-process/skills/change-verify" = ["process_assets/skills/change-verify/SKILL.md"]
+"share/engineering-process/skills/deliver-change" = ["process_assets/skills/deliver-change/SKILL.md"]
+"share/engineering-process/skills/process-improve" = ["process_assets/skills/process-improve/SKILL.md"]
 "share/engineering-process/skills/production-engineering" = [
   "process_assets/skills/production-engineering/SKILL.md",
   "process_assets/skills/production-engineering/invariants.json",
 ]
-"share/engineering-process/skills/review-change" = ["process_assets/skills/review-change/SKILL.md"]
-"share/engineering-process/skills/run-change" = ["process_assets/skills/run-change/SKILL.md"]
-"share/engineering-process/skills/start-change" = ["process_assets/skills/start-change/SKILL.md"]
-"share/engineering-process/skills/verify-change" = ["process_assets/skills/verify-change/SKILL.md"]

{engineering_process-1.2.6 → engineering_process-2.0.0}/templates/AGENTS.process.md

@@ -1,7 +1,7 @@
 <!-- engineering-process:start -->
 ## Engineering process
 
-For non-trivial delivery work, enter through the managed run-change skill and follow
+For non-trivial delivery work, enter through the managed deliver-change skill and follow
 the processctl lifecycle: start, plan, implement, verify, independent review, finish.
 
 This repository owns product decisions, domain rules, exact argument-array commands,

{engineering_process-1.2.6 → engineering_process-2.0.0}/tests/test_adoption.py

@@ -17,6 +17,11 @@ from engineering_process.contracts import ProcessError, read_json
 
 
 PROCESS_ROOT = Path(__file__).resolve().parent.parent
+PREVIOUS_SKILLS = (
+    "run-change", "start-change", "plan-change", "implement-change",
+    "verify-change", "review-change", "finish-change", "improve-process",
+    "production-engineering",
+)
 
 
 def write_json(path: Path, value: object) -> None:
@@ -135,6 +140,80 @@ class AdoptionTests(unittest.TestCase):
     def tearDown(self) -> None:
         self.temporary.cleanup()
 
+    def previous_catalog_consumer(self) -> Path:
+        consumer = (self.root / "previous-catalog").resolve()
+        write_json(consumer / ".process" / "project.json", read_json(self.root / ".process" / "project.json"))
+        managed = []
+        for name in PREVIOUS_SKILLS:
+            directory = consumer / ".agents" / "skills" / name
+            directory.mkdir(parents=True)
+            (directory / "SKILL.md").write_bytes(
+                f"---\nname: {name}\ndescription: Previous release skill.\n---\n".encode("utf-8")
+            )
+            write_json(directory / ".engineering-process.json", {
+                "schemaVersion": 1, "managedBy": "engineering-process",
+                "version": "1.2.6", "digest": "sha256:" + "0" * 64,
+            })
+            (directory / "consumer-notes.md").write_bytes(b"consumer owned\n")
+            managed.extend(f".agents/skills/{name}/{file}" for file in ("SKILL.md", ".engineering-process.json"))
+        invariant = Path(".agents/skills/production-engineering/invariants.json")
+        (consumer / invariant).write_bytes(
+            (PROCESS_ROOT / "process_assets" / "skills" / "production-engineering" / "invariants.json").read_bytes()
+        )
+        managed.append(invariant.as_posix())
+        write_json(consumer / ".process" / "process.lock", {
+            "schemaVersion": 2,
+            "process": {"package": "engineering-process", "version": "1.2.6", "digest": "sha256:" + "0" * 64},
+            "requirementsDigest": "sha256:" + "1" * 64,
+            "skills": list(PREVIOUS_SKILLS), "managedFiles": managed,
+        })
+        (consumer / "AGENTS.md").write_bytes(
+            b"# Consumer rules\n\n<!-- engineering-process:start -->\nUse run-change.\n<!-- engineering-process:end -->\n"
+        )
+        return consumer
+
+    def test_previous_catalog_migrates_all_eight_names_and_is_idempotent(self) -> None:
+        consumer = self.previous_catalog_consumer()
+        self.assertEqual("applied", apply_adoption(consumer, PROCESS_ROOT, self.requirements)["status"])
+        lock = read_json(consumer / ".process" / "process.lock")
+        expected = {path.name for path in (PROCESS_ROOT / "process_assets" / "skills").iterdir() if path.is_dir()}
+        self.assertEqual(expected, set(lock["skills"]))
+        installed = consumer / ".agents" / "skills"
+        self.assertEqual(expected, {path.name for path in installed.iterdir() if (path / "SKILL.md").is_file()})
+        for name in PREVIOUS_SKILLS:
+            with self.subTest(name=name):
+                self.assertEqual(b"consumer owned\n", (installed / name / "consumer-notes.md").read_bytes())
+                if name != "production-engineering":
+                    for filename in ("SKILL.md", ".engineering-process.json"):
+                        self.assertFalse((installed / name / filename).exists())
+                        self.assertNotIn(f".agents/skills/{name}/{filename}", lock["managedFiles"])
+        instructions = (consumer / "AGENTS.md").read_text(encoding="utf-8")
+        self.assertIn("# Consumer rules", instructions)
+        self.assertIn("deliver-change", instructions)
+        self.assertNotIn("run-change", instructions)
+        self.assertEqual("passed", check_adoption(consumer, PROCESS_ROOT, self.requirements)["status"])
+        self.assertEqual("unchanged", apply_adoption(consumer, PROCESS_ROOT, self.requirements)["status"])
+
+    def test_previous_catalog_is_restored_after_rename_cleanup_failure(self) -> None:
+        consumer = self.previous_catalog_consumer()
+        before = {path.relative_to(consumer): path.read_bytes() for path in consumer.rglob("*") if path.is_file()}
+        original_unlink = Path.unlink
+        failed = False
+
+        def fail_old_skill_removal(path: Path, *args: object, **kwargs: object) -> None:
+            nonlocal failed
+            if not failed and path == consumer / ".agents" / "skills" / "run-change" / "SKILL.md":
+                failed = True
+                raise OSError("injected old-skill cleanup failure")
+            original_unlink(path, *args, **kwargs)
+
+        with mock.patch.object(Path, "unlink", fail_old_skill_removal), self.assertRaisesRegex(ProcessError, "was rolled back"):
+            apply_adoption(consumer, PROCESS_ROOT, self.requirements)
+        self.assertTrue(failed)
+        self.assertEqual(before, {path.relative_to(consumer): path.read_bytes() for path in consumer.rglob("*") if path.is_file()})
+        self.assertEqual("applied", apply_adoption(consumer, PROCESS_ROOT, self.requirements)["status"])
+        self.assertEqual("passed", check_adoption(consumer, PROCESS_ROOT, self.requirements)["status"])
+
     def test_legacy_consumer_converges_and_second_apply_is_noop(self) -> None:
         first = apply_adoption(
             self.root, PROCESS_ROOT, self.requirements, requirements_source=self.requirements
@@ -160,7 +239,8 @@ class AdoptionTests(unittest.TestCase):
         self.assertFalse((self.root / ".process" / "automation.json").exists())
         self.assertFalse((self.root / ".process" / "adoption-migrations").exists())
         self.assertTrue((self.root / ".agents" / "skills" / "consumer-owned" / "SKILL.md").is_file())
-        self.assertTrue((self.root / ".agents" / "skills" / "improve-process" / "SKILL.md").is_file())
+        self.assertTrue((self.root / ".agents" / "skills" / "process-improve" / "SKILL.md").is_file())
+        self.assertFalse((self.root / ".agents" / "skills" / "run-change" / "SKILL.md").exists())
         self.assertEqual(
             (
                 PROCESS_ROOT
@@ -204,7 +284,7 @@ class AdoptionTests(unittest.TestCase):
         lock = read_json(self.root / ".process" / "process.lock")
         self.assertEqual(2, lock["schemaVersion"])
         self.assertEqual(VERSION, lock["process"]["version"])
-        self.assertIn(".agents/skills/run-change/SKILL.md", lock["managedFiles"])
+        self.assertIn(".agents/skills/deliver-change/SKILL.md", lock["managedFiles"])
         self.assertIn(".process/adopt-process-windows-job.py", lock["managedFiles"])
 
         second = apply_adoption(self.root, PROCESS_ROOT, self.requirements)
@@ -220,7 +300,7 @@ class AdoptionTests(unittest.TestCase):
             apply_adoption(self.root, PROCESS_ROOT, self.requirements)
 
     def test_consumer_owned_skill_name_collision_fails_closed(self) -> None:
-        collision = self.root / ".agents" / "skills" / "improve-process" / "SKILL.md"
+        collision = self.root / ".agents" / "skills" / "process-improve" / "SKILL.md"
         collision.parent.mkdir(parents=True)
         collision.write_text("consumer skill\n", encoding="utf-8")
         with self.assertRaisesRegex(ProcessError, "consumer-owned path collides"):

{engineering_process-1.2.6 → engineering_process-2.0.0}/tests/test_distribution.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import hashlib
 from pathlib import Path
 import tempfile
+import tomllib
 import unittest
 
 from engineering_process.distribution import distribution_digest, skill_digest
@@ -20,6 +21,24 @@ def framed_digest(entries: list[tuple[str, bytes]]) -> str:
 
 
 class DistributionTests(unittest.TestCase):
+    def test_packaged_skill_assets_match_the_source_catalog(self) -> None:
+        root = Path(__file__).resolve().parent.parent
+        metadata = tomllib.loads((root / "pyproject.toml").read_text(encoding="utf-8"))
+        declared = {
+            target: set(paths)
+            for target, paths in metadata["tool"]["setuptools"]["data-files"].items()
+            if target.startswith("share/engineering-process/skills/")
+        }
+        expected = {
+            f"share/engineering-process/skills/{directory.name}": {
+                path.relative_to(root).as_posix()
+                for path in directory.rglob("*") if path.is_file()
+            }
+            for directory in (root / "process_assets" / "skills").iterdir()
+            if directory.is_dir()
+        }
+        self.assertEqual(expected, declared)
+
     def test_digests_follow_canonical_relative_posix_order(self) -> None:
         entries = [
             ("skills/sample/SKILL.md", b"skill\n"),

{engineering_process-1.2.6 → engineering_process-2.0.0}/tests/test_skills.py

@@ -1,9 +1,12 @@
 from __future__ import annotations
 
+from copy import deepcopy
 from pathlib import Path
+import re
 import unittest
+from unittest import mock
 
-from engineering_process.contracts import read_json
+from engineering_process.contracts import ProcessError, read_json
 from engineering_process.skills import validate_skills
 
 
@@ -13,21 +16,63 @@ ROOT = Path(__file__).resolve().parent.parent
 class SkillTests(unittest.TestCase):
     def test_distribution_has_one_complete_reachable_skill_graph(self) -> None:
         result = validate_skills(ROOT / "process_assets" / "skills", process_root=ROOT)
-        self.assertEqual("run-change", result["entrySkill"])
+        self.assertEqual("deliver-change", result["entrySkill"])
         expected = {
-            "finish-change",
-            "implement-change",
-            "improve-process",
-            "plan-change",
+            "change-complete",
+            "change-implement",
+            "process-improve",
+            "change-plan",
             "production-engineering",
-            "review-change",
-            "run-change",
-            "start-change",
-            "verify-change",
+            "change-review",
+            "deliver-change",
+            "change-start",
+            "change-verify",
         }
         self.assertEqual(expected, set(result["skills"]))
         self.assertEqual(len(expected), result["count"])
 
+    def test_graph_rejects_missing_and_partial_transition_targets(self) -> None:
+        graph = read_json(ROOT / "process-graph.json")
+        for destination, skill in (
+            ("specified", "missing-skill"),
+            ("missing-state", "change-plan"),
+            (None, "change-plan"),
+            ("specified", None),
+        ):
+            invalid = deepcopy(graph)
+            start = next(state for state in invalid["states"] if state["id"] == "unregistered")
+            start["transitions"][0].update(nextState=destination, nextSkill=skill)
+            with self.subTest(destination=destination, skill=skill), mock.patch(
+                "engineering_process.skills.load_and_validate", return_value=invalid
+            ), self.assertRaisesRegex(ProcessError, "process graph"):
+                validate_skills(ROOT / "process_assets" / "skills", process_root=ROOT)
+
+    def test_changed_source_routes_through_implementation_before_verification(self) -> None:
+        graph = read_json(ROOT / "process-graph.json")
+        for state in graph["states"]:
+            if state["id"] in {"verified", "review-pending", "approved"}:
+                transition = next(item for item in state["transitions"] if item["result"] == "source-changed")
+                with self.subTest(state=state["id"]):
+                    self.assertEqual("implementing", transition["nextState"])
+                    self.assertEqual("change-implement", transition["nextSkill"])
+        validate_skills(ROOT / "process_assets" / "skills", process_root=ROOT)
+
+    def test_graph_rejects_ambiguous_state_owners(self) -> None:
+        graph = read_json(ROOT / "process-graph.json")
+        graph["states"][-1]["id"] = "specified"
+        with mock.patch(
+            "engineering_process.skills.load_and_validate", return_value=graph
+        ), self.assertRaisesRegex(ProcessError, "state ids must be unique"):
+            validate_skills(ROOT / "process_assets" / "skills", process_root=ROOT)
+
+    def test_readme_skill_links_resolve(self) -> None:
+        readme = (ROOT / "README.md").read_text(encoding="utf-8")
+        links = re.findall(r"\]\((process_assets/skills/[^)#]+)(?:#[^)]*)?\)", readme)
+        self.assertTrue(links)
+        for relative in links:
+            with self.subTest(relative=relative):
+                self.assertTrue((ROOT / relative).is_file())
+
     def test_graph_exposes_only_the_six_phase_cli(self) -> None:
         graph = read_json(ROOT / "process-graph.json")
         commands = {
@@ -50,10 +95,10 @@ class SkillTests(unittest.TestCase):
     def test_existing_skill_graph_guides_readiness_without_global_blocking(self) -> None:
         roots = ROOT / "process_assets" / "skills"
         required = {
-            "run-change": ("processctl project validate", "never choose the\nproduct roadmap autonomously"),
-            "start-change": ("affected\nenforced capability", "Unrelated planned gaps remain visible and non-blocking"),
-            "plan-change": ("do not add unrelated planned gaps", "checklist edit alone is not evidence"),
-            "implement-change": (
+            "deliver-change": ("processctl project validate", "never choose the\nproduct roadmap autonomously"),
+            "change-start": ("affected\nenforced capability", "Unrelated planned gaps remain visible and non-blocking"),
+            "change-plan": ("do not add unrelated planned gaps", "checklist edit alone is not evidence"),
+            "change-implement": (
                 "Never auto-promote",
                 "do not work unrelated planned\ngaps",
                 "production-engineering",
@@ -65,8 +110,8 @@ class SkillTests(unittest.TestCase):
                 "Approval is impossible",
                 "readiness declaration",
             ),
-            "verify-change": ("do not run every planned production gate", "same snapshot"),
-            "review-change": (
+            "change-verify": ("do not run every planned production gate", "same snapshot"),
+            "change-review": (
                 "Do not block the change merely because unrelated planned capabilities",
                 "Priority records impact if the finding remains unresolved",
                 "never omit an\nobservation merely to reach approval",
@@ -74,14 +119,14 @@ class SkillTests(unittest.TestCase):
                 "bounded `processSignals`",
                 "keep the assignment `review-pending`",
             ),
-            "finish-change": (
+            "change-complete": (
                 "Finish never edits\nreadiness",
                 "remaining planned\ngaps",
                 "owner and stable record URL",
                 "contract-identified final consumer adoption",
                 "Closes ISSUE, closes ISSUE",
             ),
-            "improve-process": (
+            "process-improve": (
                 "new immutable pack version",
                 "pending schema-version 7 review",
                 "never\nself-publishes or self-merges",
@@ -94,7 +139,7 @@ class SkillTests(unittest.TestCase):
                     self.assertIn(" ".join(fragment.split()), " ".join(text.split()))
 
     def test_improve_process_supports_owner_authorized_issue_handoff(self) -> None:
-        text = (ROOT / "process_assets" / "skills" / "improve-process" / "SKILL.md").read_text(encoding="utf-8")
+        text = (ROOT / "process_assets" / "skills" / "process-improve" / "SKILL.md").read_text(encoding="utf-8")
         for fragment in (
             "fix or safely block the current consumer change",
             "gh issue list --repo phuongnse/engineering-process",