@exaudeus/workrail 3.66.0 → 3.67.0

package/workflows/workflow-for-workflows.v2.json

@@ -1,788 +0,0 @@
-{
-  "id": "workflow-for-workflows",
-  "name": "Workflow Authoring Workflow",
-  "version": "2.5.0",
-  "metricsProfile": "design",
-  "description": "Use this to author or modernize a WorkRail workflow. Guides through understanding the task, defining effectiveness targets, designing architecture and quality gates, drafting, validating, assigning tags, and handing off.",
-  "about": "## Workflow Authoring Workflow\n\nThis is the standard WorkRail workflow for creating a new workflow from scratch or modernizing an existing one. It is the trust gate for all other workflows: a workflow is not considered production-ready until it has passed through here.\n\n**What it does:**\nThe workflow walks through the full authoring lifecycle: understanding the task, choosing the right baseline and archetype, designing the phase and quality-gate architecture, drafting the workflow JSON, running structural validators, auditing state fields for bloat, simulating execution against real scenarios, running an adversarial quality review, and producing a final trust handoff. For modernization tasks it builds a value inventory first to ensure enforcement mechanisms, domain knowledge, and behavioral rules are preserved or equivalently replaced.\n\n**When to use it:**\n- You want to author a new WorkRail workflow for a recurring task or problem\n- You have an existing workflow that is outdated, uses legacy patterns (pseudo-DSL, regex validation, satisfaction-score loops), or produces shallow results\n- You want a workflow that will pass the WorkRail quality bar and be trusted to run in production\n\n**What it produces:**\nA validated, tagged workflow JSON file with a `validatedAgainstSpecVersion` stamp. A final trust handoff with readiness verdict, known failure modes, residual weaknesses, and testing guidance.\n\n**How to get good results:**\nDescribe the recurring task the workflow should solve, who will run it, and what a satisfying result looks like. For modernization, point to the existing workflow file. The workflow reads the schema and authoring spec itself  -- you do not need to know the JSON format in advance.",
-  "examples": [
-    "Create a new workflow for conducting weekly engineering retrospectives",
-    "Modernize the old exploration workflow to use v2 authoring patterns and remove pseudo-DSL",
-    "Author a workflow for triaging and prioritizing incoming support tickets",
-    "Upgrade the code review workflow to add adversarial reviewer families and hard gates"
-  ],
-  "recommendedPreferences": {
-    "recommendedAutonomy": "guided",
-    "recommendedRiskPolicy": "conservative"
-  },
-  "features": [
-    "wr.features.subagent_guidance"
-  ],
-  "preconditions": [
-    "User has a recurring task or problem a workflow should solve, or an existing workflow that should be modernized.",
-    "Agent has access to file creation, editing, and terminal tools.",
-    "Agent can run workflow validators such as `npm run validate:registry` or equivalent.",
-    "Write output workflow JSON to ~/.workrail/workflows/<name>.json by default. Only write to a repo's workflows/ dir when the user explicitly asks to contribute a bundled workflow."
-  ],
-  "metaGuidance": [
-    "REFERENCE HIERARCHY: treat workflow-schema as legal truth for structure. Treat authoring-spec as canonical current guidance for what makes a workflow good. Treat authoring-provenance as optional maintainer context only.",
-    "META DISTINCTION: you are authoring or modernizing a workflow, not executing one. Keep the authored workflow's concerns separate from this meta-workflow's execution.",
-    "QUALITY-GATE ROLE: this workflow is the trust gate for other workflows. It must optimize not only for validity and modern authoring, but also for task effectiveness, false-confidence resistance, and future maintainability.",
-    "DEFAULT BEHAVIOR: self-execute with tools. Only ask the user for business decisions about the workflow being authored or modernized, not things you can learn from the schema, authoring spec, or example workflows.",
-    "AUTHORED VOICE: prompts in the authored workflow must be user-voiced. No middleware narration, no pseudo-DSL, no tutorial framing, no teaching-product language.",
-    "BASELINE DISCIPLINE: choose both an authoring baseline and an outcome baseline whenever possible. Copy structural patterns, not domain language.",
-    "VALIDATION GATE: validate with real validators, not regex approximations. When validator output and authoring assumptions conflict, runtime wins.",
-    "DEEP REVIEW: authoring integrity and outcome effectiveness are separate concerns. A workflow is not ready unless both pass.",
-    "RIGOR: always run the deepest review path -- state economy audit, execution simulation, adversarial review, and redesign if hard gates fail. There is no reduced-rigor mode.",
-    "ARTIFACT STRATEGY: the workflow JSON file is the primary output. Intermediate notes go in output.notesMarkdown. Do not create extra planning artifacts unless the workflow is genuinely complex.",
-    "V2 DURABILITY: use output.notesMarkdown as the primary durable record. Do not mirror execution state into CONTEXT.md or markdown checkpoint files.",
-    "ANTI-PATTERNS TO AVOID IN AUTHORED WORKFLOWS: no pseudo-function metaGuidance, no learning-path branching, no satisfaction-score loops, no heavy clarification batteries, no regex-as-primary-validation, no celebration phases.",
-    "MODERNIZATION DISTINCTION: remove format problems (pseudo-DSL, regex, A/B phases). Preserve or equivalently replace behavioral mechanisms (forcing functions, hard gates, domain knowledge). Never silently drop a mechanism that prevents a real failure mode.",
-    "EQUIVALENT REPLACEMENT: a replacement only qualifies if it prevents the same failure mode with similar enforcement strength. A rubric suggestion is not equivalent to a hard gate. Document the tradeoff explicitly when the replacement is weaker.",
-    "NEVER COMMIT MARKDOWN FILES UNLESS USER EXPLICITLY ASKS.",
-    "OUTPUT LOCATION: write workflow JSON to ~/.workrail/workflows/<name>.json unless user asks to contribute a bundled workflow. Never write to a repo's workflows/ dir by default -- it may be public."
-  ],
-  "references": [
-    {
-      "id": "workflow-schema",
-      "title": "Workflow JSON Schema",
-      "source": "spec/workflow.schema.json",
-      "resolveFrom": "package",
-      "purpose": "Canonical schema for validating structure and field semantics while authoring workflows. This is legal truth.",
-      "authoritative": true
-    },
-    {
-      "id": "authoring-spec",
-      "title": "Workflow Authoring Specification",
-      "source": "spec/authoring-spec.json",
-      "resolveFrom": "package",
-      "purpose": "Canonical authoring guidance, rule levels, and examples for composing workflows correctly. This is current authoring truth.",
-      "authoritative": true
-    },
-    {
-      "id": "authoring-provenance",
-      "title": "Workflow Authoring Provenance",
-      "source": "spec/authoring-spec.provenance.json",
-      "resolveFrom": "package",
-      "purpose": "Source-of-truth map showing what is canonical, derived, and non-canonical in workflow authoring guidance. Optional maintainer context.",
-      "authoritative": false
-    },
-    {
-      "id": "authoring-guide-v2",
-      "title": "Workflow Authoring Guide (v2)",
-      "source": "docs/authoring-v2.md",
-      "resolveFrom": "package",
-      "purpose": "Current v2 authoring principles, references guidance, and durable execution patterns.",
-      "authoritative": true
-    },
-    {
-      "id": "workflow-authoring-reference",
-      "title": "Workflow Authoring Reference",
-      "source": "docs/design/workflow-authoring-v2.md",
-      "resolveFrom": "package",
-      "purpose": "Detailed v2 workflow authoring patterns for loops, conditions, references, and workflow structure.",
-      "authoritative": true
-    },
-    {
-      "id": "routines-guide",
-      "title": "Routines Guide",
-      "source": "docs/design/routines-guide.md",
-      "resolveFrom": "package",
-      "purpose": "Current guide for deciding when to use delegation, direct execution, or template injection in authored workflows.",
-      "authoritative": false
-    },
-    {
-      "id": "lean-coding-workflow",
-      "title": "Lean Coding Workflow (Modern Authoring Baseline)",
-      "source": "workflows/coding-task-workflow-agentic.lean.v2.json",
-      "resolveFrom": "package",
-      "purpose": "Strong modern example for engine-native authoring patterns, loop semantics, prompt density, and bounded delegation.",
-      "authoritative": false
-    },
-    {
-      "id": "mr-review-workflow",
-      "title": "MR Review Workflow (Outcome Baseline Example)",
-      "source": "workflows/mr-review-workflow.agentic.v2.json",
-      "resolveFrom": "package",
-      "purpose": "Strong example of hypothesis, neutral fact packet, reviewer families, contradiction synthesis, final validation, and a three-dimension orthogonal assessment gate.",
-      "authoritative": false
-    },
-    {
-      "id": "bug-investigation-workflow",
-      "title": "Bug Investigation Workflow (Assessment Gate Example)",
-      "source": "workflows/bug-investigation.agentic.v2.json",
-      "resolveFrom": "package",
-      "purpose": "Simpler example of a single-dimension assessment gate on a final validation step before handoff.",
-      "authoritative": false
-    },
-    {
-      "id": "readiness-audit-workflow",
-      "title": "Production Readiness Audit (Audit Baseline Example)",
-      "source": "workflows/production-readiness-audit.json",
-      "resolveFrom": "package",
-      "purpose": "Example of a thorough evidence-driven audit workflow with explicit reviewer-family structure and confidence handling.",
-      "authoritative": false
-    }
-  ],
-  "steps": [
-    {
-      "id": "phase-0-understand-and-classify",
-      "title": "Phase 0: Understand and Classify the Authoring Task",
-      "promptBlocks": {
-        "goal": "Understand what workflow you are authoring or modernizing, and classify the task before you design anything.",
-        "constraints": [
-          [
-            {
-              "kind": "ref",
-              "refId": "wr.refs.notes_first_durability"
-            }
-          ],
-          "Explore first. Ask the user only what you genuinely cannot determine with tools and references.",
-          "Choose baselines as models, not templates. Copy structural patterns, not another workflow's domain voice."
-        ],
-        "procedure": [
-          "Read the schema, authoring spec, v2 authoring guides, and the strongest relevant example workflows.",
-          "Classify the target workflow archetype: `review_audit`, `coding_execution`, `diagnostic_investigation`, `planning_design`, `linear_operational`, or `content_analysis`.",
-          "Classify `workflowComplexity`: Simple, Medium, or Complex.",
-          "Choose an `authoringBaseline` for engine-native authoring quality and an `outcomeBaseline` for the kind of job the authored workflow should perform. If no good baseline exists for one of them, set it to `none` and explain why."
-        ],
-        "outputRequired": {
-          "notesMarkdown": "Task understanding, baseline choices, patterns to borrow or avoid, and any real open questions.",
-          "context": "Capture authoringMode, workflowArchetype, workflowComplexity, taskDescription, intendedAudience, successCriteria, domainConstraints, targetWorkflowPath, modernizationGoals, authoringBaseline, outcomeBaseline, baselineDecisionRationale, authoringPatternsToBorrow, outcomePatternsToBorrow, patternsToAvoid, openQuestions, and valueInventory (modernize_existing only)."
-        },
-        "verify": [
-          "The task is understood well enough to design the workflow without guessing blindly.",
-          "Both authoring and outcome baselines are explicit, or their absence is justified."
-        ]
-      },
-      "requireConfirmation": true,
-      "promptFragments": [
-        {
-          "id": "phase-0-modernize-inventory",
-          "when": {
-            "var": "authoringMode",
-            "equals": "modernize_existing"
-          },
-          "text": "Decide `authoringMode`: `create` or `modernize_existing`."
-        },
-        {
-          "id": "phase-0-modernize-scope",
-          "when": {
-            "var": "authoringMode",
-            "equals": "modernize_existing"
-          },
-          "text": "If `authoringMode = modernize_existing`, build a value inventory BEFORE forming opinions about what to change. Read the original and classify each meaningful mechanism: (1) enforcement mechanisms (forcing functions, hard gates, required outputs), (2) domain knowledge (problem-specific principles the agent would not otherwise know), (3) behavioral rules (persistent constraints on how the agent works). This inventory is the preservation checklist."
-        }
-      ]
-    },
-    {
-      "id": "phase-1-define-effectiveness-target",
-      "title": "Phase 1: Define the Effectiveness Target",
-      "promptBlocks": {
-        "goal": "Define what success should feel like for the authored workflow, not just what fields it should contain.",
-        "constraints": [
-          "Be specific about user satisfaction and dangerous false-confidence outcomes.",
-          "Distinguish a technically valid workflow from a satisfying one."
-        ],
-        "procedure": [
-          "State what result the authored workflow should reliably produce for its user.",
-          "List the criteria that would make the workflow feel genuinely satisfying in practice.",
-          "Name the biggest likely failure mode and the most dangerous false-confidence mode.",
-          "State what would make the workflow technically correct but still disappointing."
-        ],
-        "outputRequired": {
-          "notesMarkdown": "Effectiveness target, satisfaction criteria, failure modes, and false-confidence risks.",
-          "context": "Capture effectivenessTarget, userSatisfactionCriteria, primaryFailureMode, dangerousFalseConfidenceModes, likelyWeakOutcomeModes, and trustRisk."
-        },
-        "verify": [
-          "The authored workflow now has a clear outcome bar, not just an authoring bar."
-        ]
-      },
-      "requireConfirmation": false
-    },
-    {
-      "id": "phase-2-design-workflow-architecture",
-      "title": "Phase 2: Design the Workflow Architecture",
-      "promptBlocks": {
-        "goal": "Decide the workflow architecture before you write JSON.",
-        "constraints": [
-          "Separate workflow architecture from quality-gate architecture. This phase is about the authored workflow itself.",
-          "Keep delegation bounded and keep ownership with the main agent."
-        ],
-        "procedure": [
-          "Decide the phase list, one-line goal for each phase, and overall ordering.",
-          "Design loops with explicit exit rules, bounded maxIterations, and real reasons for another pass.",
-          "Decide confirmation gates, delegation vs template injection vs direct execution, promptFragments, references, artifacts, and metaGuidance."
-        ],
-        "outputRequired": {
-          "notesMarkdown": "Structured workflow outline, loop design, confirmation design, delegation design, artifact plan, and modernization mapping.",
-          "context": "Capture workflowOutline, loopDesign, confirmationDesign, delegationDesign, artifactPlan, contextModel, voiceStrategy, routineAudit, delegationBoundaries, templateInjectionPlan, modernizationStrategy, legacyMapping, behaviorPreservationNotes, and valuePreservationMap (modernize_existing only)."
-        },
-        "verify": [
-          "The authored workflow architecture is coherent before JSON drafting begins."
-        ]
-      },
-      "promptFragments": [
-        {
-          "id": "phase-2-simple-scope",
-          "when": {
-            "var": "workflowComplexity",
-            "equals": "Simple"
-          },
-          "text": "This is a Simple workflow. Keep the architecture lightweight: a flat phase list, no loops required, minimal confirmations, no delegation. The goal is clarity and direct execution, not structural sophistication."
-        },
-        {
-          "id": "phase-2-simple-direct",
-          "when": {
-            "var": "workflowComplexity",
-            "equals": "Simple"
-          },
-          "text": "For Simple workflows, keep the architecture linear and compact. Do not invent loops or ceremony unless the task truly needs them."
-        },
-        {
-          "id": "phase-2-modernize-mapping",
-          "when": {
-            "var": "authoringMode",
-            "equals": "modernize_existing"
-          },
-          "text": "If `authoringMode = modernize_existing`, decide preserve-in-place, restructure, or rewrite. For each item in valueInventory, record: `preserved` (structurally present with equivalent enforcement), `replaced` (new mechanism prevents same failure mode  -- justify equivalence), or `dropped` (intentionally removed  -- justify the loss). Phase-level mapping alone is insufficient; track what was inside each restructured or removed phase."
-        }
-      ],
-      "requireConfirmation": {
-        "var": "workflowComplexity",
-        "not_equals": "Simple"
-      }
-    },
-    {
-      "id": "phase-3-design-quality-architecture",
-      "title": "Phase 3: Design the Quality-Gate Architecture",
-      "promptBlocks": {
-        "goal": "Design how the authored workflow will avoid shallow results, false confidence, and state bloat.",
-        "constraints": [
-          "This phase is about the authored workflow's quality model, not its basic phase list.",
-          "Prefer explicit quality structure over hoping the agent will infer it."
-        ],
-        "procedure": [
-          "Decide whether the authored workflow needs a hypothesis step, neutral fact packet, reviewer or validator families, contradiction loop, final validation bundle, or explicit blind-spot handling.",
-          "Design the confidence model, blind-spot model, and state economy plan.",
-          "Decide the hard-gate dimensions that would make the authored workflow unsafe or unsatisfying if they fail. If hard gates exist, implement them using the native `assessments` + `assessmentRefs` + `assessmentConsequences` schema fields rather than informal notes or `requireConfirmation` alone. Each dimension should capture a distinct orthogonal failure mode -- not restate the workflow's existing confidence band. See `mr-review-workflow.agentic.v2.json` and `bug-investigation.agentic.v2.json` as exemplars.",
-          "Write the redesign triggers that should force architectural revision rather than cosmetic refinement."
-        ],
-        "outputRequired": {
-          "notesMarkdown": "Quality architecture, confidence model, blind-spot model, state economy plan, and hard-gate triggers.",
-          "context": "Capture qualityArchitecture, confidenceModel, blindSpotModel, stateEconomyPlan, reviewBundlePlan, qualityGateTriggers, and hardGateModel."
-        },
-        "verify": [
-          "The authored workflow has an explicit plan for false-confidence resistance and quality review."
-        ]
-      },
-      "promptFragments": [
-        {
-          "id": "phase-3-simple-scope",
-          "when": {
-            "var": "workflowComplexity",
-            "equals": "Simple"
-          },
-          "text": "This is a Simple workflow. Quality architecture should be proportional: identify one primary false-confidence mode and one key hard gate. Skip full reviewer family design -- a single self-executed review pass is sufficient."
-        }
-      ]
-    },
-    {
-      "id": "phase-4-draft-or-revise",
-      "title": "Phase 4: Draft or Revise the Workflow",
-      "promptBlocks": {
-        "goal": "Write the workflow JSON file using the architecture and quality model you already chose.",
-        "constraints": [
-          "The schema defines what is legal. The authoring spec defines what is good.",
-          "Write prompts in the user's voice. Vary prompt density by step needs rather than using one density everywhere.",
-          "If you are modernizing, preserve what still fits the workflow's purpose. Do not rewrite just because a workflow is old."
-        ],
-        "procedure": [
-          "If `authoringMode = create` and no filename was specified, ask the user for the filename before writing.",
-          "If `authoringMode = modernize_existing`, default to editing `targetWorkflowPath` unless there is a strong reason to create a new variant or file.",
-          "Write the workflow file. Keep protocol requirements explicit, loops bounded, confirmations meaningful, and metaGuidance clean."
-        ],
-        "outputRequired": {
-          "notesMarkdown": "Draft status and any notable authoring choices that are important to later review.",
-          "context": "Capture workflowFilePath and draftComplete."
-        },
-        "verify": [
-          "The workflow file exists and reflects the chosen architecture rather than an improvised one."
-        ]
-      },
-      "promptFragments": [
-        {
-          "id": "phase-4-simple-fast",
-          "when": {
-            "var": "workflowComplexity",
-            "equals": "Simple"
-          },
-          "text": "For Simple workflows, keep the file compact and linear. Do not create extra metaGuidance or loops unless the task truly needs them."
-        }
-      ],
-      "requireConfirmation": false
-    },
-    {
-      "id": "phase-5-validate",
-      "type": "loop",
-      "title": "Phase 5: Structural Validation Loop",
-      "loop": {
-        "type": "while",
-        "conditionSource": {
-          "kind": "artifact_contract",
-          "contractRef": "wr.contracts.loop_control",
-          "loopId": "validation_loop"
-        },
-        "maxIterations": 3
-      },
-      "body": [
-        {
-          "id": "phase-5a-run-validation",
-          "title": "Run Validation",
-          "promptBlocks": {
-            "goal": "Run the real workflow validators against the drafted workflow.",
-            "constraints": [
-              "Do not rely on reading the JSON and eyeballing it.",
-              "If runtime and authoring assumptions conflict, runtime wins."
-            ],
-            "procedure": [
-              "Run the available validation tools or commands such as `npm run validate:registry`, schema validation, or the MCP validation surface.",
-              "If validation fails, list the actual errors, fix them in the workflow file, and re-run validation.",
-              "If validation passes cleanly, say so plainly."
-            ],
-            "outputRequired": {
-              "notesMarkdown": "Validation results, actual errors if any, and what was fixed.",
-              "context": "Capture validationErrors and validationPassed."
-            },
-            "verify": [
-              "Validation results are based on real validators, not approximations."
-            ]
-          },
-          "promptFragments": [
-            {
-              "id": "phase-5a-thorough",
-              "text": "After structural validation passes, also check the workflow manually against required-level authoring-spec rules and fix any failures before moving on."
-            }
-          ],
-          "requireConfirmation": false
-        },
-        {
-          "id": "phase-5b-loop-decision",
-          "title": "Validation Loop Decision",
-          "promptBlocks": {
-            "goal": "Decide whether structural validation needs another pass.",
-            "constraints": [
-              "Use validator state, not vibes."
-            ],
-            "procedure": [
-              "If all errors are fixed and validation passes, stop.",
-              "If you fixed errors but have not re-validated yet, continue.",
-              "If you hit the iteration limit, stop and record what remains."
-            ],
-            "outputRequired": {
-              "artifact": "Emit a `wr.loop_control` artifact for `validation_loop` with `decision` set to `continue` or `stop`."
-            },
-            "verify": [
-              "The loop decision matches the actual validation state."
-            ]
-          },
-          "outputContract": {
-            "contractRef": "wr.contracts.loop_control"
-          },
-          "requireConfirmation": false
-        }
-      ]
-    },
-    {
-      "id": "phase-5-escalation",
-      "title": "Validation Escalation",
-      "runCondition": {
-        "var": "validationPassed",
-        "equals": false
-      },
-      "promptBlocks": {
-        "goal": "Stop execution. A structurally broken workflow must not proceed to the quality gate loop. Surface the errors and require user intervention.",
-        "constraints": [
-          "Present the situation honestly."
-        ],
-        "procedure": [
-          "List the remaining validation errors and assess their severity.",
-          "Stop and require user intervention. Do not proceed into the quality gate loop with a structurally broken workflow. The user must explicitly decide how to resolve each remaining error before this workflow can continue."
-        ]
-      },
-      "requireConfirmation": true
-    },
-    {
-      "id": "phase-6-quality-gate-loop",
-      "type": "loop",
-      "title": "Phase 6: Quality-Gate Loop",
-      "loop": {
-        "type": "while",
-        "conditionSource": {
-          "kind": "artifact_contract",
-          "contractRef": "wr.contracts.loop_control",
-          "loopId": "quality_gate_loop"
-        },
-        "maxIterations": 3
-      },
-      "body": [
-        {
-          "id": "phase-6a-state-economy-audit",
-          "title": "State Economy Audit",
-          "promptBlocks": {
-            "goal": "Check whether every context field in the authored workflow earns its keep.",
-            "constraints": [
-              "A field is justified only if it materially affects routing, synthesis, confidence, or handoff quality.",
-              "Do not keep bookkeeping fields just because they sound organized."
-            ],
-            "procedure": [
-              "For each meaningful captured context field, record where it is set, where it is consumed, what decision or outcome it influences, and what gets worse if it is removed.",
-              "Classify each field as `keep`, `wire`, or `remove`.",
-              "Fix weak or unused fields directly in the workflow file."
-            ],
-            "outputRequired": {
-              "notesMarkdown": "State field audit with keep/wire/remove decisions and any fixes applied.",
-              "context": "Capture stateFieldAudit, unusedOrWeakFields, and stateEconomyPassed."
-            },
-            "verify": [
-              "Weak or unused fields are either wired meaningfully or removed."
-            ]
-          },
-          "requireConfirmation": false,
-          "assessmentRefs": [
-            "state-economy-gate"
-          ],
-          "assessmentConsequences": [
-            {
-              "when": {
-                "anyEqualsLevel": "low"
-              },
-              "effect": {
-                "kind": "require_followup",
-                "guidance": "state_economy low -- one or more context fields are unused, weakly consumed, or carry no decision weight. Remove or wire them before proceeding: trace a concrete downstream use for each field, or delete it from the workflow."
-              }
-            }
-          ]
-        },
-        {
-          "id": "phase-6b-execution-simulation",
-          "title": "Execution Simulation",
-          "promptBlocks": {
-            "goal": "Simulate what would happen if the authored workflow ran on the user's real task.",
-            "constraints": [
-              "This is about practical utility, not only context-flow correctness.",
-              "Flag places where the workflow would produce paperwork, generic output, or false confidence instead of value."
-            ],
-            "procedure": [
-              "Trace the authored workflow step by step against the user's actual task or the closest realistic scenario.",
-              "For each step, ask: what would the agent actually do, what context would it have, what would it likely produce, and what would the next step inherit?",
-              "Also trace at least one degraded or edge-case path  -- not just the happy path. Ask: what happens when a condition evaluates unexpectedly, a loop has nothing to iterate, a runCondition skips a phase, or the user provides minimal input? Quality gates that only protect the happy path are not quality gates.",
-              "Identify likely weak steps, likely unsatisfying outputs, and likely false-confidence modes.",
-              "For any loop in the workflow, explicitly check: does the exit condition have structural teeth (artifact contract, bounded maxIterations), or does it rely on prose instructions the engine cannot enforce?",
-              "Fix issues directly in the workflow file when the right improvement is clear."
-            ],
-            "outputRequired": {
-              "notesMarkdown": "Execution simulation findings, likely weak steps, unsatisfying outputs, false-confidence risks, and any fixes applied.",
-              "context": "Capture simulationFindings, likelyWeakSteps, likelyUnsatisfyingOutputs, falseConfidenceFindings, and outcomeEffectivenessPassed."
-            },
-            "verify": [
-              "The simulation judges likely usefulness, not just structural legality."
-            ]
-          },
-          "promptFragments": [
-            {
-              "id": "phase-6b-modernize-check",
-              "when": {
-                "var": "authoringMode",
-                "equals": "modernize_existing"
-              },
-              "text": "For modernize_existing: after tracing the workflow forward, check each item in valueInventory. For each enforcement mechanism and domain knowledge item: would the modernized workflow produce the same behavior? Any item where the answer is no or weaker is a loss  -- fix it directly or record the accepted tradeoff with justification."
-            }
-          ],
-          "requireConfirmation": false,
-          "assessmentRefs": [
-            "simulation-outcome-gate"
-          ],
-          "assessmentConsequences": [
-            {
-              "when": {
-                "anyEqualsLevel": "low"
-              },
-              "effect": {
-                "kind": "require_followup",
-                "guidance": "simulation_outcome low -- the simulation found likely unsatisfying or false-confidence outputs that were not fixed inline. Address the identified weak steps or degraded-path failures before the adversarial review."
-              }
-            }
-          ]
-        },
-        {
-          "id": "phase-6c-adversarial-quality-review",
-          "title": "Adversarial Quality Review",
-          "promptBlocks": {
-            "goal": "Review the authored workflow as a quality gate, not just as a valid JSON file.",
-            "constraints": [
-              "Authoring integrity and outcome effectiveness are separate concerns. Score both.",
-              "Reviewer-family or validator output is evidence, not authority."
-            ],
-            "procedure": [
-              "Score these dimensions 0-2 with one sentence of evidence each: `voiceClarity`, `ceremonyLevel`, `loopSoundness`, `delegationBoundedness`, `artifactClarity`, `taskEffectiveness`, `falseConfidenceResistance`, `stateMinimality`, `coverageSharpness`, `domainFit`, `handoffUtility`, and `complexityScaling` (0 = has appropriate fast paths or scope-sensitive branching for simpler inputs; 2 = single-weight, over-engineers simple cases)2 = single-weight), `enforcementStrength` (0 = behavioral rules have structural teeth; 2 = important rules are prose-only with no enforcement mechanism), and `modernizationDiscipline` (0 = every valueInventory item preserved, equivalently replaced with justification, or dropped with justification; 2 = items missing or replaced with weaker versions without justification  -- score 0 for create mode).",
-              "Run an adversarial review bundle with these lenses: `engine_native_reviewer`, `task_effectiveness_reviewer`, `state_economy_reviewer`, `false_confidence_reviewer`, `domain_fit_reviewer`, and `maintainer_reviewer`.",
-              "Synthesize what the review confirmed, what it challenged, and what changed your mind.",
-              "When scoring `falseConfidenceResistance`, explicitly check: do the workflow's quality gates protect edge cases and degraded paths, or only the happy path? A workflow that passes its own checks on ideal input but fails silently on minimal or unexpected input scores 2.",
-              "Set hard-gate failures whenever any of these are materially weak: `taskEffectiveness`, `falseConfidenceResistance`, `stateMinimality`, `coverageSharpness`, `domainFit`, or `handoffUtility`, and `complexityScaling` (0 = has appropriate fast paths or scope-sensitive branching for simpler inputs; 2 = single-weight, over-engineers simple cases).",
-              "Set `authoringIntegrityPassed = true` only if structural and authoring-quality dimensions are all acceptable. Set `outcomeEffectivenessPassed = true` only if the workflow is likely to achieve satisfying results for the user."
-            ],
-            "outputRequired": {
-              "notesMarkdown": "Quality review scores, adversarial review findings, hard-gate failures, and the current redesign severity.",
-              "context": "Capture reviewScores, hardGateFailures, authoringIntegrityPassed, outcomeEffectivenessPassed, qualityReviewSummary, and redesignSeverity."
-            },
-            "verify": [
-              "Hard gates reflect real user-trust risk, not cosmetic imperfections."
-            ]
-          },
-          "promptFragments": [
-            {
-              "id": "phase-6c-rigor",
-              "text": "Always use adversarial reviewer lanes. Assume the first review is not enough -- use the full adversarial bundle unless a hard limitation makes it impossible."
-            },
-            {
-              "id": "phase-6c-heritage-review",
-              "when": {
-                "var": "authoringMode",
-                "equals": "modernize_existing"
-              },
-              "text": "For modernize_existing: add a heritage_reviewer to the adversarial bundle. Its job is to check each valueInventory item and find what was lost or weakened  -- it ignores format improvements. It must answer: which enforcement mechanisms are now prose-only? Which domain knowledge items are absent? Which behavioral rules were removed without equivalent replacement? Heritage_reviewer findings drive enforcementStrength and modernizationDiscipline scores."
-            }
-          ],
-          "requireConfirmation": false,
-          "validationCriteria": [
-            {
-              "type": "contains",
-              "value": "complexityScaling",
-              "message": "Review must score complexityScaling"
-            }
-          ],
-          "assessmentRefs": [
-            "authoring-integrity-gate",
-            "outcome-effectiveness-gate"
-          ],
-          "assessmentConsequences": [
-            {
-              "when": {
-                "anyEqualsLevel": "low"
-              },
-              "effect": {
-                "kind": "require_followup",
-                "guidance": "authoring_integrity low -- structural or quality dimensions are unacceptable; fix voice, ceremony, loop, delegation, or state problems before this workflow can be trusted. outcome_effectiveness low -- task effectiveness, false-confidence resistance, coverage sharpness, or domain fit are materially weak; redesign, do not patch."
-              }
-            }
-          ]
-        },
-        {
-          "id": "phase-6d-redesign-and-revalidate",
-          "title": "Redesign and Revalidate",
-          "promptBlocks": {
-            "goal": "If hard gates fail, redesign the workflow instead of polishing around the problem.",
-            "constraints": [
-              "Minor cosmetic refinement is not enough when task effectiveness or false-confidence resistance is weak.",
-              "If structure changes, re-run real validators before leaving this step."
-            ],
-            "procedure": [
-              "Otherwise classify the needed redesign severity as `minor`, `architectural`, or `unsafe_to_ship` and apply the necessary fixes directly to the workflow file.",
-              "If the redesign changed structure, run the real validators again and update the validation state before leaving this step."
-            ],
-            "outputRequired": {
-              "notesMarkdown": "Redesign actions taken, why they were needed, and whether revalidation passed.",
-              "context": "Capture redesignApplied, validationPassed, and remainingConcerns."
-            },
-            "verify": [
-              "Structural redesign problems are handled as redesign problems, not cosmetic ones."
-            ]
-          },
-          "requireConfirmation": false,
-          "runCondition": {
-            "or": [
-              {
-                "var": "authoringIntegrityPassed",
-                "equals": false
-              },
-              {
-                "var": "outcomeEffectivenessPassed",
-                "equals": false
-              }
-            ]
-          }
-        },
-        {
-          "id": "phase-6e-quality-loop-decision",
-          "title": "Quality Loop Decision",
-          "promptBlocks": {
-            "goal": "Decide whether the quality-gate loop needs another pass.",
-            "constraints": [
-              "Use hard gates and actual remaining concerns, not vibes."
-            ],
-            "procedure": [
-              "Continue if `authoringIntegrityPassed = false`.",
-              "Otherwise continue if `outcomeEffectivenessPassed = false`.",
-              "Otherwise continue if `hardGateFailures` is not empty.",
-              "Otherwise continue if `redesignSeverity` is `architectural` or `unsafe_to_ship` and you have not yet re-reviewed the redesigned workflow.",
-              "Otherwise continue if `validationPassed = false` after redesign.",
-              "Otherwise stop."
-            ],
-            "outputRequired": {
-              "artifact": "Emit a `wr.loop_control` artifact for `quality_gate_loop` with `decision` set to `continue` or `stop`."
-            },
-            "verify": [
-              "The workflow does not stop while hard trust problems remain."
-            ]
-          },
-          "outputContract": {
-            "contractRef": "wr.contracts.loop_control"
-          },
-          "requireConfirmation": false
-        }
-      ]
-    },
-    {
-      "id": "phase-7a-assign-tags",
-      "title": "Phase 7a: Assign Tags",
-      "promptBlocks": {
-        "goal": "Register the workflow in the catalog: assign tags in spec/workflow-tags.json and write about and examples fields into the workflow JSON so humans and agents can discover and understand the workflow.",
-        "procedure": [
-          "Read spec/workflow-tags.json to see the available tags and their 'when' phrases.",
-          "Based on the workflow's purpose and description, select 1-3 tags from the closed set (coding, review_audit, investigation, design, documentation, tickets, learning, routines, authoring).",
-          "Check whether the workflow ID already exists in the `workflows` section. If it does, update the existing entry tags rather than adding a duplicate. If it does not exist, add a new entry under 'workflows' in spec/workflow-tags.json: { \"tags\": [\"<tag1>\"] }.",
-          "If the workflow is a test fixture or internal utility not meant for end-user discovery, add 'hidden': true.",
-          "Save the tags file. Do not modify any other field.",
-          "Write the 'about' field into the workflow JSON: a markdown string (100-400 words) written for a human deciding whether to use this workflow. Cover what it does, when to use it, what it produces, and how to get good results. This is a user-facing surface -- not agent instructions (use metaGuidance for that).",
-          "Write the 'examples' field into the workflow JSON: an array of 2-4 short, concrete goal strings (10-120 chars each) showing what this workflow is used for. Each example should be specific enough to be informative -- not generic ('implement a feature'). These appear in list_workflows output so agents can communicate concrete goal phrasing to users.",
-          "Skip 'about' and 'examples' only if the workflow is marked hidden: true."
-        ],
-        "constraints": [
-          "Only use tags from the closed set. Do not invent new tags.",
-          "If the workflow already has an entry in the tags file, update it rather than adding a duplicate.",
-          "Tags should reflect what the workflow does, not what it is named.",
-          "Write 'about' for humans, not agents -- do not copy metaGuidance or step prompt text into it.",
-          "Examples must be specific to this workflow; reject generic examples that would fit any workflow."
-        ],
-        "outputRequired": {
-          "notesMarkdown": "List the assigned tags with a one-line justification for each. Confirm about and examples were written."
-        }
-      },
-      "requireConfirmation": false
-    },
-    {
-      "id": "phase-7b-declare-metrics-profile",
-      "title": "Phase 7b: Declare metricsProfile",
-      "promptBlocks": {
-        "goal": "Declare the metricsProfile field in the authored workflow JSON, or explicitly justify omitting it. The metricsProfile field enables engine-injected metrics instrumentation footers in step prompts. When set, the engine injects context key accumulation reminders into every step prompt -- guiding compliant agents to report outcome, commit SHAs, PR numbers, and diff stats at session completion. Without this field, captureConfidence is always 'none' and no session metrics are collected.",
-        "procedure": [
-          "Choose the correct profile based on what the workflow produces:",
-          "  - 'coding': produces code commits. Use for implementation, refactoring, bug-fix, migration, and documentation-writing workflows.",
-          "  - 'review': produces a review decision on a PR or MR. Use for code review, audit, and change validation workflows.",
-          "  - 'research': produces a finding or recommendation but no commits. Use for investigation, diagnosis, and analysis workflows.",
-          "  - 'design': produces a design artifact (pitch, spec, ADR, architecture doc) but no commits.",
-          "  - 'ticket': creates or updates work items in an external system (Jira, GitHub Issues, Linear).",
-          "  - 'none': meta-workflow, authoring tool, utility routine, or no measurable outcome. Set explicitly and document the reason.",
-          "Add `\"metricsProfile\": \"<profile>\"` as a top-level field in the workflow JSON, after `recommendedPreferences` if that field exists.",
-          "If choosing 'none', record the justification in your notes so the decision is auditable."
-        ],
-        "constraints": [
-          "Do not invent a new profile value. The closed set is: 'coding', 'review', 'research', 'design', 'ticket', 'none'.",
-          "The engine does NOT derive the profile from tags automatically. You must set it explicitly.",
-          "workflow-for-workflows itself produces a workflow JSON artifact (a design output) -- use 'design'. It does not commit code."
-        ],
-        "outputRequired": {
-          "notesMarkdown": "State the chosen metricsProfile and a one-line justification. If omitting, explain why."
-        }
-      },
-      "requireConfirmation": false
-    },
-    {
-      "id": "phase-7-final-trust-handoff",
-      "title": "Phase 7: Final Trust Handoff",
-      "promptBlocks": {
-        "goal": "Summarize the authored or modernized workflow as a trust decision, not just a file edit.",
-        "constraints": [
-          "Keep it concise. The workflow file is the deliverable, not the summary."
-        ],
-        "procedure": [
-          "Stamp the workflow file: read the current `version` from `spec/authoring-spec.json` and write `validatedAgainstSpecVersion: <N>` as a top-level field in the workflow JSON. Commit the change  -- the stamp has no effect if only saved locally.",
-          "State the workflow file path and name, whether it was created or modernized, and what it does in one sentence.",
-          "Summarize the step structure, loops, confirmations, and delegation profile.",
-          "Report validation status, authoring-integrity status, and outcome-effectiveness status.",
-          "Set a final `workflowReadinessVerdict`: `ready`, `ready_with_conditions`, or `not_ready`.",
-          "List the main improvements, residual weaknesses, trust risks if any, and how to test the workflow."
-        ],
-        "outputRequired": {
-          "notesMarkdown": "Final trust handoff covering readiness verdict, validation status, strengths, residual weaknesses, and testing guidance.",
-          "context": "Capture workflowReadinessVerdict, trustRiskSummary, knownFailureModes, and residualWeaknesses."
-        },
-        "verify": [
-          "The final handoff makes clear whether WorkRail should trust this workflow."
-        ]
-      },
-      "notesOptional": true,
-      "requireConfirmation": false
-    }
-  ],
-  "validatedAgainstSpecVersion": 3,
-  "assessments": [
-    {
-      "id": "state-economy-gate",
-      "purpose": "Every context field in the authored workflow earns its keep: it is set, consumed, and influences a concrete decision or output.",
-      "dimensions": [
-        {
-          "id": "state_economy",
-          "purpose": "All context fields have a traceable downstream use. No field is captured speculatively or carried without purpose.",
-          "levels": [
-            "low",
-            "high"
-          ]
-        }
-      ]
-    },
-    {
-      "id": "simulation-outcome-gate",
-      "purpose": "A concrete execution simulation has been completed and identified weak steps, likely unsatisfying outputs, and false-confidence modes -- and any found were fixed inline.",
-      "dimensions": [
-        {
-          "id": "simulation_outcome",
-          "purpose": "Simulation completed over at least one happy path and one degraded/edge-case path. Issues found were fixed or explicitly accepted.",
-          "levels": [
-            "low",
-            "high"
-          ]
-        }
-      ]
-    },
-    {
-      "id": "authoring-integrity-gate",
-      "purpose": "The authored workflow is structurally sound and meets authoring quality standards: voice, ceremony, loops, delegation, and state are all acceptable.",
-      "dimensions": [
-        {
-          "id": "authoring_integrity",
-          "purpose": "Structural and authoring-quality dimensions passed the adversarial review. No hard gate failure on voice, ceremony, loopSoundness, delegationBoundedness, or stateMinimality.",
-          "levels": [
-            "low",
-            "high"
-          ]
-        }
-      ]
-    },
-    {
-      "id": "outcome-effectiveness-gate",
-      "purpose": "The authored workflow is likely to produce genuinely satisfying results: task effectiveness, false-confidence resistance, coverage sharpness, domain fit, and handoff utility are all acceptable.",
-      "dimensions": [
-        {
-          "id": "outcome_effectiveness",
-          "purpose": "The workflow passes adversarial review on task effectiveness, falseConfidenceResistance, coverageSharpness, domainFit, and handoffUtility. No hard gate failure on any outcome dimension.",
-          "levels": [
-            "low",
-            "high"
-          ]
-        }
-      ]
-    }
-  ]
-}