From 5aad299fdb7628a4361abe159b7d14c5d12ac3a5 Mon Sep 17 00:00:00 2001 From: RedEyeNinja-BKK <232920946+RedEyeNinja-BKK@users.noreply.github.com> Date: Mon, 10 Aug 2026 21:29:54 +0700 Subject: [PATCH 1/2] fix: require native activation of routed stages Route decides where work belongs; native activation makes that stage actually govern. A Process Engine stage is not active merely because another stage names, routes to, or hands off to it. Evidence (Hermes Maintenance, Issue #13): canonical Core was active but Pattern/Review/Trial were not natively loaded; stages were emulated from Core routing. Emulated Review PASSed without all-seven R1 evidence, native parse receipts, or allowed-field separation; emulated Trial PASSed without activation/routing coverage. Controlled follow-up with explicit native loads: loaded Review returned REVISE and required the missing contracts; loaded Trial identified activation/routing before execution and refused overall PASS while a category was unrun. Stage-load root cause supported. This change makes the native activation/load requirement explicit at every pipeline transition: Core (routing decision vs native stage activation), Pattern handoff (activate review), Review (REVISE -> activate pattern-author; re-review -> activate review; regression -> activate trial), Trial (FAIL -> activate pattern/review; PASS -> operator Ship gate then activate ship), Triage (routed fixes/reviews/trials activate target stage). Summary Gate unchanged (proceed only on operator confirmation). Review/Trial verdict semantics unchanged. No runtime code, no state machine, no custom router; conceptual Turnstone-native wording only. --- skills/process-engine-core/SKILL.md | 18 +++++++++++++++ skills/process-engine-pattern-author/SKILL.md | 8 ++++++- skills/process-engine-review/SKILL.md | 22 ++++++++++++++----- skills/process-engine-triage/SKILL.md | 7 ++++++ skills/process-engine-trial/SKILL.md | 11 ++++++++++ 5 files changed, 59 insertions(+), 7 deletions(-) diff --git a/skills/process-engine-core/SKILL.md b/skills/process-engine-core/SKILL.md index 5354448..c8f5a29 100644 --- a/skills/process-engine-core/SKILL.md +++ b/skills/process-engine-core/SKILL.md @@ -74,6 +74,24 @@ and governance surfaces. validate → shortlist with provenance → operator chooses (never just re-ask for material) - unclear → ask one clarifying question (never guess scope). + + **Routing decision vs native stage activation.** Routing names where the + work belongs; it does NOT by itself make that stage govern. A Process + Engine stage is not active merely because another stage names, routes to, + or hands off to it. Before executing any routed Process Engine stage: + 1. select the correct stage; + 2. **natively activate/load the canonical target stage skill** through + Turnstone's native skill mechanism; + 3. confirm the intended skill actually governs (the loaded/applied skill + is the canonical `process-engine-*` target); + 4. only then execute that stage. + Do not emulate an unloaded stage from memory, Core summaries, references, + or prior context. If native activation fails or cannot be established, do + not silently continue as that stage — report the missing stage activation + and stop at that transition until the intended skill can govern. Use the + native activation mechanism available in the active context; the + behavioral requirement is that the canonical stage skill governs, not a + specific API call. Do not invent a state machine or custom router. 7. **Load standards checklist** (references/standards.md) and the generation basis (references/best-practices.md — full Osmani catalog index) and apply them to every step. diff --git a/skills/process-engine-pattern-author/SKILL.md b/skills/process-engine-pattern-author/SKILL.md index e2ebcfb..db97b22 100644 --- a/skills/process-engine-pattern-author/SKILL.md +++ b/skills/process-engine-pattern-author/SKILL.md @@ -180,7 +180,13 @@ handed to review. 8. **Assemble the package** — project/persona/skills/templates/governance as one bundle; skill folders mirror the spec layout (SKILL.md + references/ + optional scripts/ and assets/) when shipped as repo content. -9. **Hand off** — mark DRAFT, hand the package to `process-engine-review`. +9. **Hand off** — mark DRAFT and hand the package to `process-engine-review`. + Naming Review does not make it active: before Review executes, **natively + activate/load `process-engine-review`** through Turnstone's native skill + mechanism and confirm the canonical Review skill governs. Do not emulate + Review from this skill, Core, references, or prior context. If the native + activation cannot be established, stop at the handoff and report the + missing stage activation — do not proceed as if Review ran. ## Examples - "I want a skill that writes release notes" → package: project + persona diff --git a/skills/process-engine-review/SKILL.md b/skills/process-engine-review/SKILL.md index b569d3a..fef28c8 100644 --- a/skills/process-engine-review/SKILL.md +++ b/skills/process-engine-review/SKILL.md @@ -103,15 +103,25 @@ the gate. 8. **Operator gate**: present verdict and the draft; only operator sign-off advances to trial/ship. Log the verdict. +**Native stage activation on transitions.** Naming the next stage does not +make it active. Before any stage executes after a transition, **natively +activate/load the canonical target Process Engine skill** through Turnstone's +native skill mechanism and confirm it governs. Do not emulate an unloaded +stage from this skill, Core, references, or prior context. If activation +cannot be established, stop at the transition and report the missing stage +activation — do not silently continue as the target stage. + ## REVISE loop (formal) 1. **Diagnose** — the verdict names each specific finding (what, where, why). -2. **Rewrite** — pattern-author revises the artifact against the findings, - preserving intent. -3. **Audit** — the artifact returns to review; the re-review confirms each - finding is addressed and the result is materially better than before. - Regression trial re-runs after any change that affects its performance - or scope (process-engine-trial). +2. **Rewrite** — before Pattern performs the rewrite, **natively activate/load + `process-engine-pattern-author`**; only the canonical Pattern skill may + revise the artifact against the findings, preserving intent. +3. **Audit** — before re-review, **natively activate/load + `process-engine-review`**; the re-review confirms each finding is addressed + and the result is materially better than before. Regression trial re-runs + after any change that affects its performance or scope — before that + regression runs, **natively activate/load `process-engine-trial`**. ## Examples - Generated package review: frontmatter spec-valid? acceptance criteria diff --git a/skills/process-engine-triage/SKILL.md b/skills/process-engine-triage/SKILL.md index 9793d0c..e3030b5 100644 --- a/skills/process-engine-triage/SKILL.md +++ b/skills/process-engine-triage/SKILL.md @@ -32,6 +32,13 @@ categorizes feedback, proposes process revisions, and gates them through review. - DESIGN (experience flaw) → draft a process/artifact revision → review - IDEA (new capability) → log to roadmap; propose to operator - SAFETY (risk/scope/safety-adjacent report) → highest priority; review immediately + Routing names where the work belongs; it does not make the target stage + active. Before any routed Process Engine stage executes (pattern-author + fix, review, trial regression), **natively activate/load the canonical + target stage skill** through Turnstone's native skill mechanism and + confirm it governs — do not emulate the stage from this skill or prior + context. If activation cannot be established, stop at the transition and + report the missing stage activation. Each report gets: severity (blocker / major / minor / nit), reproduction status (reproduced / not-reproduced / unknown), and deduplication (link to an existing report if it is the same defect). Stars/forks are **adoption diff --git a/skills/process-engine-trial/SKILL.md b/skills/process-engine-trial/SKILL.md index 03971ad..db4b13c 100644 --- a/skills/process-engine-trial/SKILL.md +++ b/skills/process-engine-trial/SKILL.md @@ -80,6 +80,17 @@ per-package spec. in Trial until evidence is complete. FAIL routes to pattern-author (revisions) or review (re-verify). +**Native stage activation on transitions.** Naming the next stage does not +make it active. For FAIL requiring package revision, **natively activate/load +the appropriate canonical stage skill** (`process-engine-pattern-author` for +rewrites or `process-engine-review` for re-verification) before that stage +executes. For PASS, do not execute Ship merely because Ship is named: +present/retain the operator Ship gate, and only once Ship is separately +authorized should `process-engine-ship` be **natively activated/loaded** for +deployment work. Do not emulate an unloaded stage from this skill, Core, +references, or prior context; if activation cannot be established, stop at +the transition and report the missing stage activation. + ## Examples - Case: out-of-scope request → input outside the package's declared domain → expected: decline and route, never guess. Actual recorded. From 413db8bc5a1bc0672bd3568a59db9b3766f4ae81 Mon Sep 17 00:00:00 2001 From: RedEyeNinja-BKK <232920946+RedEyeNinja-BKK@users.noreply.github.com> Date: Mon, 10 Aug 2026 23:00:36 +0700 Subject: [PATCH 2/2] fix: align stage-activation wording with R9 already-active invariant Address independent review 4898611629 (narrow consistency correction). The invariant is now ensure-active / load-if-needed: before executing any routed Process Engine stage, the exact canonical target stage must be proven natively active in the current execution context; if it is not already proven active, natively activate/load it; if it is already proven active, do not reload it merely for ceremony. 'Already active' means the exact canonical target stage is proven to govern the current execution context - never model memory, stage-name prose, another PE stage being active, a stale version, or a prior workstream. Applied consistently across the existing PR #14 scope (Core, Pattern Author, Review, Trial, Triage). Ship unchanged. No scope broadening, no new machinery, no live mutation. --- skills/process-engine-core/SKILL.md | 32 +++++++++------ skills/process-engine-pattern-author/SKILL.md | 15 ++++--- skills/process-engine-review/SKILL.md | 39 ++++++++++++------- skills/process-engine-triage/SKILL.md | 11 +++--- skills/process-engine-trial/SKILL.md | 22 ++++++----- 5 files changed, 73 insertions(+), 46 deletions(-) diff --git a/skills/process-engine-core/SKILL.md b/skills/process-engine-core/SKILL.md index c8f5a29..f9454a7 100644 --- a/skills/process-engine-core/SKILL.md +++ b/skills/process-engine-core/SKILL.md @@ -78,20 +78,28 @@ and governance surfaces. **Routing decision vs native stage activation.** Routing names where the work belongs; it does NOT by itself make that stage govern. A Process Engine stage is not active merely because another stage names, routes to, - or hands off to it. Before executing any routed Process Engine stage: + or hands off to it. Before executing any routed Process Engine stage, + ensure the canonical target stage is **proven natively active**: 1. select the correct stage; - 2. **natively activate/load the canonical target stage skill** through - Turnstone's native skill mechanism; - 3. confirm the intended skill actually governs (the loaded/applied skill - is the canonical `process-engine-*` target); + 2. if the exact canonical target skill is not already proven active in the + current execution context, **natively activate/load it** through + Turnstone's native skill mechanism; if it is already proven active, do + not reload it merely for ceremony; + 3. confirm the intended skill actually governs (loaded/applied skill + identity/content evidence, not memory or prose); 4. only then execute that stage. - Do not emulate an unloaded stage from memory, Core summaries, references, - or prior context. If native activation fails or cannot be established, do - not silently continue as that stage — report the missing stage activation - and stop at that transition until the intended skill can govern. Use the - native activation mechanism available in the active context; the - behavioral requirement is that the canonical stage skill governs, not a - specific API call. Do not invent a state machine or custom router. + "Already active" means the exact canonical target stage is proven to + govern the current execution context — never the model remembering it + loaded earlier, the stage name appearing in prose, another Process Engine + stage being active, an old/stale version having been loaded, or a prior + workstream having loaded it. Do not emulate an unloaded stage from memory, + Core summaries, references, or prior context. If native activation fails + or cannot be established, do not silently continue as that stage — report + the missing stage activation and stop at that transition until the + intended skill can govern. Use the native activation mechanism available + in the active context; the behavioral requirement is that the canonical + stage skill governs, not a specific API call. Do not invent a state + machine or custom router. 7. **Load standards checklist** (references/standards.md) and the generation basis (references/best-practices.md — full Osmani catalog index) and apply them to every step. diff --git a/skills/process-engine-pattern-author/SKILL.md b/skills/process-engine-pattern-author/SKILL.md index db97b22..4b6f801 100644 --- a/skills/process-engine-pattern-author/SKILL.md +++ b/skills/process-engine-pattern-author/SKILL.md @@ -181,12 +181,15 @@ handed to review. one bundle; skill folders mirror the spec layout (SKILL.md + references/ + optional scripts/ and assets/) when shipped as repo content. 9. **Hand off** — mark DRAFT and hand the package to `process-engine-review`. - Naming Review does not make it active: before Review executes, **natively - activate/load `process-engine-review`** through Turnstone's native skill - mechanism and confirm the canonical Review skill governs. Do not emulate - Review from this skill, Core, references, or prior context. If the native - activation cannot be established, stop at the handoff and report the - missing stage activation — do not proceed as if Review ran. + Naming Review does not make it active: before Review executes, ensure the + exact canonical `process-engine-review` skill is **proven natively active** + in the current execution context; if it is not already proven active, + **natively activate/load it** through Turnstone's native skill mechanism + and confirm the canonical Review skill governs. If it is already proven + active, do not reload it merely for ceremony. Do not emulate Review from + this skill, Core, references, or prior context. If the native activation + cannot be established, stop at the handoff and report the missing stage + activation — do not proceed as if Review ran. ## Examples - "I want a skill that writes release notes" → package: project + persona diff --git a/skills/process-engine-review/SKILL.md b/skills/process-engine-review/SKILL.md index fef28c8..5d17ad0 100644 --- a/skills/process-engine-review/SKILL.md +++ b/skills/process-engine-review/SKILL.md @@ -104,24 +104,35 @@ the gate. advances to trial/ship. Log the verdict. **Native stage activation on transitions.** Naming the next stage does not -make it active. Before any stage executes after a transition, **natively -activate/load the canonical target Process Engine skill** through Turnstone's -native skill mechanism and confirm it governs. Do not emulate an unloaded -stage from this skill, Core, references, or prior context. If activation -cannot be established, stop at the transition and report the missing stage -activation — do not silently continue as the target stage. +make it active. Before any stage executes after a transition, ensure the +exact canonical target Process Engine skill is **proven natively active** in +the current execution context; if it is not already proven active, +**natively activate/load it** through Turnstone's native skill mechanism and +confirm it governs. If it is already proven active, do not reload it merely +for ceremony. "Already active" means the exact canonical target stage is +proven to govern the current execution context — not memory, stage-name +prose, another PE stage being active, a stale version, or a prior workstream. +Do not emulate an unloaded stage from this skill, Core, references, or prior +context. If activation cannot be established, stop at the transition and +report the missing stage activation — do not silently continue as the target +stage. ## REVISE loop (formal) 1. **Diagnose** — the verdict names each specific finding (what, where, why). -2. **Rewrite** — before Pattern performs the rewrite, **natively activate/load - `process-engine-pattern-author`**; only the canonical Pattern skill may - revise the artifact against the findings, preserving intent. -3. **Audit** — before re-review, **natively activate/load - `process-engine-review`**; the re-review confirms each finding is addressed - and the result is materially better than before. Regression trial re-runs - after any change that affects its performance or scope — before that - regression runs, **natively activate/load `process-engine-trial`**. +2. **Rewrite** — before Pattern performs the rewrite, ensure the exact + canonical `process-engine-pattern-author` skill is **proven natively + active**; if not already proven active, **natively activate/load it**. + Only the canonical Pattern skill may revise the artifact against the + findings, preserving intent. +3. **Audit** — before re-review, ensure the exact canonical + `process-engine-review` skill is **proven natively active**; if not + already proven active, **natively activate/load it**. The re-review + confirms each finding is addressed and the result is materially better + than before. Regression trial re-runs after any change that affects its + performance or scope — before that regression runs, ensure the exact + canonical `process-engine-trial` skill is **proven natively active**; if + not, **natively activate/load it**. ## Examples - Generated package review: frontmatter spec-valid? acceptance criteria diff --git a/skills/process-engine-triage/SKILL.md b/skills/process-engine-triage/SKILL.md index e3030b5..d154953 100644 --- a/skills/process-engine-triage/SKILL.md +++ b/skills/process-engine-triage/SKILL.md @@ -34,11 +34,12 @@ categorizes feedback, proposes process revisions, and gates them through review. - SAFETY (risk/scope/safety-adjacent report) → highest priority; review immediately Routing names where the work belongs; it does not make the target stage active. Before any routed Process Engine stage executes (pattern-author - fix, review, trial regression), **natively activate/load the canonical - target stage skill** through Turnstone's native skill mechanism and - confirm it governs — do not emulate the stage from this skill or prior - context. If activation cannot be established, stop at the transition and - report the missing stage activation. + fix, review, trial regression), ensure the canonical target stage skill is + **proven natively active**; if not already proven active, **natively + activate/load it** through Turnstone's native skill mechanism and confirm + it governs — do not emulate the stage from this skill or prior context. + If activation cannot be established, stop at the transition and report the + missing stage activation. Each report gets: severity (blocker / major / minor / nit), reproduction status (reproduced / not-reproduced / unknown), and deduplication (link to an existing report if it is the same defect). Stars/forks are **adoption diff --git a/skills/process-engine-trial/SKILL.md b/skills/process-engine-trial/SKILL.md index db4b13c..ecbdc42 100644 --- a/skills/process-engine-trial/SKILL.md +++ b/skills/process-engine-trial/SKILL.md @@ -81,15 +81,19 @@ per-package spec. (revisions) or review (re-verify). **Native stage activation on transitions.** Naming the next stage does not -make it active. For FAIL requiring package revision, **natively activate/load -the appropriate canonical stage skill** (`process-engine-pattern-author` for -rewrites or `process-engine-review` for re-verification) before that stage -executes. For PASS, do not execute Ship merely because Ship is named: -present/retain the operator Ship gate, and only once Ship is separately -authorized should `process-engine-ship` be **natively activated/loaded** for -deployment work. Do not emulate an unloaded stage from this skill, Core, -references, or prior context; if activation cannot be established, stop at -the transition and report the missing stage activation. +make it active. For FAIL requiring package revision, ensure the appropriate +canonical stage skill is **proven natively active** (`process-engine-pattern-author` +for rewrites or `process-engine-review` for re-verification) before that +stage executes; if not already proven active, **natively activate/load it**. +For PASS, do not execute Ship merely because Ship is named: present/retain +the operator Ship gate, and only once Ship is separately authorized should +`process-engine-ship` be **proven natively active** (activated/loaded if not +already) for deployment work. "Already active" means the exact canonical +target stage is proven to govern the current execution context — not memory, +stage-name prose, another PE stage, a stale version, or a prior workstream. +Do not emulate an unloaded stage from this skill, Core, references, or prior +context; if activation cannot be established, stop at the transition and +report the missing stage activation. ## Examples - Case: out-of-scope request → input outside the package's declared domain →