@tiic-tech/openworkflow 0.1.0 → 0.1.2

package/dist/cli/src/dev/verifyWorkflowE2E.js

@@ -19,16 +19,23 @@ async function main() {
         const codexHome = join(tempRoot, "codex-home");
         const env = { ...process.env, CODEX_HOME: codexHome };
         await run(["node", CLI, "init", target, "--tools", "codex", "--force"], env);
-        await run(["node", CLI, "sync", "--root", target, "--tools", "codex"], env);
+        await run(["node", CLI, "sync", "--root", target], env);
         await run(["node", CLI, "doctor", "--root", target, "--tools", "codex"], env);
         await run(["node", CLI, "validate", "--root", target], env);
+        await verifyAgentOnboarding(target, env);
         const runtime = await loadRuntime(target);
+        await verifyCurrentState(runtime);
         await verifyVisionPhase(runtime);
         await verifyValidationPhase(runtime);
+        await verifyInternalProtoPipelinePhase(runtime);
         await verifyPrototypePhase(runtime);
         await verifyTunePhase(runtime);
         await verifyInternalDecisionPhase(runtime);
+        await verifyProductionCommandPhases(runtime);
         await verifyDisplayLabels(runtime);
+        await verifyBriefReadModel(runtime);
+        await verifyCommandReadiness(runtime);
+        await verifySummaryReadModel(runtime);
     }
     finally {
         await rm(tempRoot, { recursive: true, force: true });
@@ -38,48 +45,100 @@ async function main() {
 }
 async function loadRuntime(target) {
     const commandIndex = await readYaml(join(target, ".openworkflow", "audit", "COMMAND_AUDIT_INDEX.yaml"));
+    const currentState = await readYaml(join(target, ".openworkflow", "CURRENT_STATE.yaml"));
     const contextPackets = await readYaml(join(target, ".openworkflow", "audit", "CONTEXT_PACKETS.yaml"));
+    const artifactContracts = await readYaml(join(target, ".openworkflow", "audit", "ARTIFACT_CONTRACTS.yaml"));
     return {
         target,
+        currentState,
         commands: records(commandIndex, "commands", "runtime"),
         packets: records(contextPackets, "packets", "runtime"),
+        artifacts: records(artifactContracts, "artifacts", "runtime"),
     };
 }
+async function verifyCurrentState(runtime) {
+    const phase = "current-state";
+    assertPhase(phase, runtime.currentState.contract_id === "workflow:current-state", "current state contract id mismatch");
+    assertPhase(phase, runtime.currentState.active_stage === "workflow", "initial active stage should be workflow");
+    assertPhase(phase, runtime.currentState.next_command === "/ow:vision", "initial next command should be /ow:vision");
+    assertListIncludes(phase, stringList(runtime.currentState, "read_this_first", phase), ".openworkflow/CURRENT_STATE.yaml", "current state does not point to itself");
+    const lastDecision = recordField(runtime.currentState, "last_decision", phase);
+    assertPhase(phase, "outcome" in lastDecision, "current state last_decision missing outcome");
+}
 async function verifyVisionPhase(runtime) {
     const phase = "vision";
     const source = command("vision", phase);
     const protocol = protocolFor(source, phase);
-    assertPhase(phase, protocol.interactionMode === "conversation-first-sustained-grill", "source protocol is not sustained grill");
+    assertPhase(phase, protocol.interactionMode === "delayed-compile-product-interrogation", "source protocol is not delayed-compile product interrogation");
     assertExactList(phase, protocol.handoffCommands, ["/ow:validation"], "vision source handoffs changed");
     assertListIncludes(phase, protocol.forbiddenOutputs, ".openworkflow/validation/**", "vision can create validation artifacts");
     assertListIncludes(phase, protocol.forbiddenOutputs, ".openworkflow/prototypes/**", "vision can create prototype artifacts");
-    assertListIncludes(phase, protocol.auditCheckpoints.before, "Start in conversation mode and ask the next useful vision question before writing artifacts.", "vision does not start conversation-first");
+    assertSomeIncludes(phase, protocol.auditCheckpoints.before, "product partner, requirements interrogator, and intent compiler", "vision source missing three-role framing");
+    assertSomeIncludes(phase, protocol.auditCheckpoints.before, "do not start by creating or updating durable vision files", "vision does not start conversation-first");
     assertSomeIncludes(phase, protocol.auditCheckpoints.during, "make each question depend on the previous answer", "vision does not enforce progressive questioning");
-    assertSomeIncludes(phase, protocol.auditCheckpoints.after, "user confirms readiness", "vision handoff does not require user readiness confirmation");
+    assertSomeIncludes(phase, protocol.auditCheckpoints.after, "proto_readiness.status", "vision compile does not require proto-readiness");
+    assertSomeIncludes(phase, protocol.auditCheckpoints.after, "user readiness", "vision handoff does not require user readiness confirmation");
     const generated = commandRecord(runtime, "vision", phase);
     assertPhase(phase, stringField(generated, "visibility", phase) === "user", "generated vision command is not user visible");
     assertExactList(phase, stringList(generated, "handoff_commands", phase), ["/ow:validation"], "generated vision handoffs changed");
     assertListIncludes(phase, stringList(generated, "forbidden_outputs", phase), ".openworkflow/prototypes/**", "generated vision can create prototypes");
     const packet = packetRecord(runtime, "/ow:vision", phase);
-    assertSomeIncludes(phase, nestedStringList(packet, ["audit_checkpoints", "before"], phase), "ask the next useful vision question", "context packet lost conversation-first checkpoint");
-    assertSomeIncludes(phase, nestedStringList(packet, ["audit_checkpoints", "during"], phase), "Cover mandatory vision dimensions", "context packet lost mandatory coverage checkpoint");
-    assertSomeIncludes(phase, nestedStringList(packet, ["audit_checkpoints", "after"], phase), "user confirms readiness", "context packet lost readiness gate");
+    assertSomeIncludes(phase, nestedStringList(packet, ["audit_checkpoints", "before"], phase), "Ask the next useful vision question", "context packet lost conversation-first checkpoint");
+    assertSomeIncludes(phase, nestedStringList(packet, ["audit_checkpoints", "during"], phase), "Cover mandatory vision and proto-readiness dimensions", "context packet lost mandatory proto-readiness checkpoint");
+    assertSomeIncludes(phase, nestedStringList(packet, ["audit_checkpoints", "after"], phase), "proto-readiness", "context packet lost proto-readiness gate");
     const skill = await readSkill(runtime, "ow-vision");
+    assertIncludes(phase, skill, ".openworkflow/CURRENT_STATE.yaml", "skill missing current state loading guidance");
+    assertIncludes(phase, skill, "clear stale current_question", "skill missing stale question closure guidance");
+    assertIncludes(phase, skill, "summary_policy", "skill missing summary policy guidance");
+    assertIncludes(phase, skill, "<vision_role>", "skill missing vision role block");
+    assertIncludes(phase, skill, "Act as product partner", "skill missing product partner role");
+    assertIncludes(phase, skill, "Act as requirements interrogator", "skill missing requirements interrogator role");
+    assertIncludes(phase, skill, "Act as intent compiler", "skill missing intent compiler role");
+    assertIncludes(phase, skill, "<interaction_modes>", "skill missing delayed compile modes");
+    assertIncludes(phase, skill, "Interview mode is the default", "skill missing interview mode");
+    assertIncludes(phase, skill, "Checkpoint mode writes", "skill missing checkpoint mode");
+    assertIncludes(phase, skill, "Compile mode writes", "skill missing compile mode");
+    assertIncludes(phase, skill, "<agent_first_consumer>", "skill missing Agent-first consumer guidance");
+    assertIncludes(phase, skill, "Treat the next implementing Agent as the first consumer", "skill missing first-consumer framing");
+    assertIncludes(phase, skill, "vision_delta must preserve enough handoff intelligence", "skill missing compact handoff intelligence guidance");
     assertIncludes(phase, skill, "<conversation_first>", "skill missing conversation_first block");
     assertIncludes(phase, skill, "Ask exactly one question", "skill no longer limits vision to one focused question");
     assertIncludes(phase, skill, "<mandatory_coverage>", "skill missing mandatory coverage block");
-    assertIncludes(phase, skill, "Do not hand off to /ow:validation until mandatory coverage is addressed", "skill lost validation handoff gate");
+    assertIncludes(phase, skill, "<proto_readiness_gate>", "skill missing proto-readiness gate");
+    assertIncludes(phase, skill, "VISION.md is ready only when /ow:proto can derive", "skill missing proto-readiness acceptance");
+    assertIncludes(phase, skill, "Do not hand off to /ow:validation until mandatory coverage is addressed, proto-readiness", "skill lost validation handoff gate");
     assertIncludes(phase, skill, "not on a fixed number of turns", "skill permits fixed-turn readiness");
     assertIncludes(phase, skill, "<artifact_checkpoint>", "skill missing artifact checkpoint separation");
-    const template = await readYaml(join(runtime.target, ".openworkflow", "vision", "_templates", "VISION_SESSION.yaml"));
+    const template = recordField(artifactRecord(runtime, "vision_session", phase), "template", phase);
+    const visionDelta = recordField(template, "vision_delta", phase);
+    assertPhase(phase, Object.hasOwn(visionDelta, "problem"), "vision template missing problem field");
+    assertPhase(phase, Object.hasOwn(visionDelta, "ai_native_role"), "vision template missing ai_native_role field");
+    assertPhase(phase, Object.hasOwn(visionDelta, "success_signals"), "vision template missing success_signals field");
+    assertPhase(phase, Object.hasOwn(visionDelta, "failure_signals"), "vision template missing failure_signals field");
+    const strategicCore = recordField(template, "strategic_core", phase);
+    assertPhase(phase, Object.hasOwn(strategicCore, "target_user"), "vision template missing strategic_core.target_user");
+    assertPhase(phase, Object.hasOwn(strategicCore, "core_differentiator"), "vision template missing strategic_core.core_differentiator");
+    const productSystemSeed = recordField(template, "product_system_seed", phase);
+    assertPhase(phase, Object.hasOwn(productSystemSeed, "primary_loop"), "vision template missing product_system_seed.primary_loop");
+    assertPhase(phase, Object.hasOwn(productSystemSeed, "anti_goals"), "vision template missing product_system_seed.anti_goals");
+    const protoReadiness = recordField(template, "proto_readiness", phase);
+    assertPhase(phase, protoReadiness.status === "missing", "vision proto_readiness should default to missing");
+    assertPhase(phase, Object.hasOwn(protoReadiness, "missing_for_proto"), "vision template missing proto_readiness.missing_for_proto");
+    assertPhase(phase, Object.hasOwn(protoReadiness, "prototype_direction_seeds"), "vision template missing proto_readiness.prototype_direction_seeds");
+    assertPhase(phase, Object.hasOwn(protoReadiness, "validation_target"), "vision template missing proto_readiness.validation_target");
+    const coverage = recordField(template, "coverage", phase);
+    assertPhase(phase, Object.hasOwn(coverage, "proto_readiness"), "vision template missing coverage.proto_readiness");
     const handoff = recordField(template, "handoff", phase);
     assertPhase(phase, handoff.ready === false, "vision template should default to not ready");
     assertPhase(phase, handoff.next_command === null, "vision template should not default to validation handoff");
+    assertPhase(phase, Object.hasOwn(handoff, "blockers"), "vision handoff template missing blockers field");
+    assertPhase(phase, Object.hasOwn(handoff, "readiness_notes"), "vision handoff template missing readiness_notes field");
 }
 async function verifyValidationPhase(runtime) {
     const phase = "validation";
     const source = command("validation", phase);
     const protocol = protocolFor(source, phase);
+    assertPhase(phase, protocol.interactionMode === "prototype-validation-target-compiler", "validation source protocol is not prototype target compiler");
     assertListIncludes(phase, protocol.requiredContext, ".openworkflow/vision/VISION_CONTRACT.yaml", "validation no longer requires vision contract");
     assertListIncludes(phase, protocol.forbiddenOutputs, ".openworkflow/prototypes/**", "validation can create prototype artifacts");
     assertExactList(phase, protocol.handoffCommands, ["/ow:proto", "/ow:vision"], "validation source handoffs changed");
@@ -89,78 +148,185 @@ async function verifyValidationPhase(runtime) {
     assertListExcludes(phase, handoffs, "/ow:decision", "generated validation exposes manual decision");
     const packet = packetRecord(runtime, "/ow:validation", phase);
     assertListIncludes(phase, stringList(packet, "required", phase), ".openworkflow/vision/VISION_CONTRACT.yaml", "context packet does not require vision contract");
-    assertSomeIncludes(phase, nestedStringList(packet, ["audit_checkpoints", "during"], phase), "single highest-risk validation question", "validation does not focus the core risk");
-    assertSomeIncludes(phase, nestedStringList(packet, ["audit_checkpoints", "after"], phase), "prototype brief", "validation does not produce prototype brief");
-    const template = await readYaml(join(runtime.target, ".openworkflow", "validation", "_templates", "VALIDATION.yaml"));
+    assertSomeIncludes(phase, nestedStringList(packet, ["audit_checkpoints", "before"], phase), "force /ow:proto to invent product strategy", "validation does not return to vision when strategy is missing");
+    assertSomeIncludes(phase, nestedStringList(packet, ["audit_checkpoints", "during"], phase), "central uncertainty", "validation does not focus the central uncertainty");
+    assertSomeIncludes(phase, nestedStringList(packet, ["audit_checkpoints", "during"], phase), "prototype_experiment", "validation does not define prototype experiment");
+    assertSomeIncludes(phase, nestedStringList(packet, ["audit_checkpoints", "during"], phase), "observable_signals", "validation does not define observable signals");
+    assertSomeIncludes(phase, nestedStringList(packet, ["audit_checkpoints", "after"], phase), "agent_readiness_gate", "validation does not write readiness gate");
+    const skill = await readSkill(runtime, "ow-validation");
+    assertIncludes(phase, skill, "prototype-validation-target-compiler", "skill missing validation compiler mode");
+    assertIncludes(phase, skill, "central_uncertainty", "skill missing central uncertainty artifact guidance");
+    assertIncludes(phase, skill, "prototype_experiment", "skill missing prototype experiment artifact guidance");
+    assertIncludes(phase, skill, "observable_signals", "skill missing observable signals artifact guidance");
+    assertIncludes(phase, skill, "decision_rules", "skill missing decision rules artifact guidance");
+    assertIncludes(phase, skill, "Return to /ow:vision", "skill missing return-to-vision gate");
+    assertIncludes(phase, skill, "Do not generate prototype prompts", "skill missing no-prototype boundary");
+    const template = recordField(artifactRecord(runtime, "validation_target", phase), "template", phase);
     assertPhase(phase, "prototype_scope" in template, "validation template missing prototype_scope");
+    assertPhase(phase, "central_uncertainty" in template, "validation template missing central_uncertainty");
+    assertPhase(phase, "target_behavior" in template, "validation template missing target_behavior");
+    assertPhase(phase, "prototype_experiment" in template, "validation template missing prototype_experiment");
+    assertPhase(phase, "observable_signals" in template, "validation template missing observable_signals");
+    assertPhase(phase, "decision_rules" in template, "validation template missing decision_rules");
+    assertPhase(phase, "vision_gaps" in template, "validation template missing vision_gaps");
+    const agentGate = recordField(template, "agent_readiness_gate", phase);
+    const trigger = recordField(template, "trigger", phase);
+    assertPhase(phase, trigger.mode === "user_explicit", "validation template should default trigger mode to user_explicit");
+    assertPhase(phase, trigger.requested_command === "/ow:validation", "validation template should default trigger requested_command to /ow:validation");
+    assertPhase(phase, agentGate.status === "thin_validation", "validation template should default agent readiness to thin_validation");
+    assertPhase(phase, agentGate.write_authority === "/ow:validation", "validation template should preserve /ow:validation write authority");
     assertPhase(phase, stringList(template, "decision_options", phase).includes("needs_more_evidence"), "validation template missing decision options");
 }
 async function verifyPrototypePhase(runtime) {
     const phase = "prototype";
     const source = command("proto", phase);
     const protocol = protocolFor(source, phase);
-    assertPhase(phase, protocol.interactionMode === "classified-prototype-creation", "prototype source protocol is not classified creation");
+    assertPhase(phase, protocol.interactionMode === "image-first-strategic-proto-prompt-pack", "prototype source protocol is not image-first prompt pack");
     assertDiscoveryHandoffs(phase, protocol.handoffCommands, "source prototype handoffs");
     assertListIncludes(phase, protocol.allowedOutputs, ".openworkflow/decisions/<id>/DECISION.yaml", "prototype cannot write decision audit");
-    assertSomeIncludes(phase, protocol.auditCheckpoints.before, "Classify prototype mode", "prototype does not classify mode first");
-    assertSomeIncludes(phase, protocol.auditCheckpoints.before, "Detect reference inputs", "prototype does not detect references");
-    assertSomeIncludes(phase, protocol.auditCheckpoints.during, "high-fidelity static concept", "prototype does not require static concept");
+    assertSomeIncludes(phase, protocol.conditionalOutputs ?? [], ".openworkflow/validation/<id>/VALIDATION.yaml", "prototype cannot auto-write validation artifacts");
+    assertSomeIncludes(phase, protocol.auditCheckpoints.before, "auto-run /ow:validation", "prototype does not auto-run validation when missing");
+    assertSomeIncludes(phase, protocol.auditCheckpoints.before, "trigger.mode agent_auto", "prototype auto validation does not record provenance");
+    assertSomeIncludes(phase, protocol.auditCheckpoints.before, "high-quality prototype prompts", "prototype does not verify vision and validation quality before prompt generation");
+    assertSomeIncludes(phase, protocol.auditCheckpoints.before, "askUserQuestion", "prototype does not ask for direction count when missing");
+    assertSomeIncludes(phase, protocol.auditCheckpoints.during, "5-8 strategic prototype hypotheses", "prototype does not generate strategic hypotheses");
+    assertSomeIncludes(phase, protocol.auditCheckpoints.during, "prompt_text_manifest.status is ready_for_image_generation", "prototype does not gate image generation on prompt text readiness");
+    assertSomeIncludes(phase, protocol.auditCheckpoints.during, "post_validate.status is pass", "prototype does not gate image generation on post_validate pass");
+    assertSomeIncludes(phase, protocol.auditCheckpoints.during, "post_validate.status is fail", "prototype does not route failed post_validate back to prompt repair");
+    assertSomeIncludes(phase, protocol.auditCheckpoints.during, "Batch-generate prototype images", "prototype does not batch-generate images after prompt text");
+    assertSomeIncludes(phase, protocol.auditCheckpoints.after, "PROTO_PROMPT_PACK.yaml", "prototype does not write prompt pack");
+    assertSomeIncludes(phase, protocol.auditCheckpoints.after, "image_generation collection state", "prototype does not write image generation collection state");
     assertSomeIncludes(phase, protocol.auditCheckpoints.after, "decision audit record internally", "prototype does not write decision audit internally");
     assertSomeIncludes(phase, protocol.antiPatterns, "Do not ask the user to manually invoke /ow:decision", "prototype permits manual decision handoff");
+    assertSomeIncludes(phase, protocol.antiPatterns, "Do not generate HTML", "prototype permits HTML generation");
     const generated = commandRecord(runtime, "proto", phase);
     assertDiscoveryHandoffs(phase, stringList(generated, "handoff_commands", phase), "generated prototype handoffs");
     assertListIncludes(phase, stringList(generated, "allowed_outputs", phase), ".openworkflow/decisions/<id>/DECISION.yaml", "generated prototype cannot write decision audit");
+    assertListIncludes(phase, stringList(generated, "allowed_outputs", phase), ".openworkflow/prototypes/<id>/PROTO_PROMPT_PACK.yaml", "generated prototype missing prompt pack output");
+    assertListIncludes(phase, stringList(generated, "conditional_outputs", phase), ".openworkflow/validation/<id>/VALIDATION.yaml", "generated prototype missing conditional validation output");
     const packet = packetRecord(runtime, "/ow:proto", phase);
-    assertSomeIncludes(phase, nestedStringList(packet, ["audit_checkpoints", "during"], phase), "before HTML", "context packet lost visual-first ordering");
+    assertSomeIncludes(phase, nestedStringList(packet, ["audit_checkpoints", "before"], phase), "askUserQuestion", "context packet lost direction-count question behavior");
+    assertSomeIncludes(phase, nestedStringList(packet, ["audit_checkpoints", "during"], phase), "product_experience_model", "context packet lost product experience model behavior");
+    assertSomeIncludes(phase, nestedStringList(packet, ["audit_checkpoints", "during"], phase), "strategic prototype hypotheses", "context packet lost strategic prompt behavior");
+    assertSomeIncludes(phase, nestedStringList(packet, ["audit_checkpoints", "during"], phase), "post_validate.status is pass", "context packet lost post_validate pass gate");
+    assertSomeIncludes(phase, nestedStringList(packet, ["audit_checkpoints", "during"], phase), "Batch-generate prototype images", "context packet lost image generation behavior");
     assertSomeIncludes(phase, nestedStringList(packet, ["audit_checkpoints", "after"], phase), "decision audit record internally", "context packet lost internal decision audit");
     const skill = await readSkill(runtime, "ow-proto");
     for (const tag of [
-        "prototype_classification",
-        "reference_extraction",
-        "visual_first_path",
-        "design_seed_protocol",
-        "verification_protocol",
-        "self_critique",
+        "internal_proto_pipeline",
+        "validation_consumption",
+        "preflight_quality_gate",
+        "direction_count_policy",
+        "strategic_prompt_pack",
+        "prompt_text_manifest",
+        "post_validate_gate",
+        "image_generation",
+        "image_only_boundary",
+        "review_evidence",
         "internal_decision_audit",
     ]) {
         assertIncludes(phase, skill, `<${tag}>`, `skill missing ${tag} block`);
     }
-    assertIncludes(phase, skill, "image generation before HTML", "skill lost image generation before HTML rule");
-    assertIncludes(phase, skill, "reference-pattern extraction", "skill lost reference-pattern extraction wording");
-    assertIncludes(phase, skill, "repair pass before evidence handoff", "skill lost critique repair gate");
+    assertIncludes(phase, skill, "prompt_pack_type: strategic_proto_prompt_pack", "skill lost strategic prompt pack rule");
+    assertIncludes(phase, skill, "product_experience_model", "skill lost product experience model rule");
+    assertIncludes(phase, skill, "anti_generic_constraints", "skill lost anti-generic constraints rule");
+    assertIncludes(phase, skill, "/ow:vision2prompt and /ow:prompt2proto are internal commands", "skill lost internal proto pipeline rule");
+    assertIncludes(phase, skill, "trigger.mode: agent_auto", "skill lost auto validation provenance rule");
+    assertIncludes(phase, skill, "askUserQuestion", "skill lost direction-count question rule");
+    assertIncludes(phase, skill, "resolved_count: 3", "skill lost delegated default direction count");
+    assertIncludes(phase, skill, "post_validate.status: pass", "skill lost post_validate pass requirement");
+    assertIncludes(phase, skill, "post_validate.status: skipped", "skill lost post_validate skip requirement");
+    assertIncludes(phase, skill, "post_validate.status is fail", "skill lost post_validate failure route");
+    assertIncludes(phase, skill, "Batch-generate prototype images", "skill lost batch image generation rule");
+    assertIncludes(phase, skill, "Do not write HTML, CSS, runnable prototypes", "skill lost image-only boundary");
     assertIncludes(phase, skill, "decision_record", "skill does not expose decision artifact contract for internal audit");
     assertNotIncludes(phase, extractBlock(skill, "handoff_commands"), "/ow:decision", "skill exposes decision in prototype handoffs");
     const artifacts = getDiscoveryArtifactContractsForCommand("/ow:proto").map((artifact) => artifact.artifactType);
     assertListIncludes(phase, artifacts, "prototype_evidence", "source proto artifacts missing prototype evidence");
     assertListIncludes(phase, artifacts, "decision_record", "source proto artifacts missing decision record");
-    const template = await readYaml(join(runtime.target, ".openworkflow", "prototypes", "_templates", "EVIDENCE.yaml"));
-    assertPhase(phase, "reference_analysis" in template, "prototype template missing reference analysis");
-    assertPhase(phase, "visual_concept_policy" in template, "prototype template missing visual concept policy");
-    assertPhase(phase, "concept_evidence" in template, "prototype template missing concept evidence");
-    assertPhase(phase, "implementation_evidence" in template, "prototype template missing implementation evidence");
-    assertPhase(phase, "verification" in template, "prototype template missing verification evidence");
-    assertPhase(phase, "self_critique" in template, "prototype template missing self critique");
-    const conceptPolicy = recordField(template, "visual_concept_policy", phase);
-    assertPhase(phase, conceptPolicy.image_generation === "generated|skipped_by_user|not_applicable", "prototype template lost image generation policy");
-    const critique = recordField(template, "self_critique", phase);
-    for (const key of ["philosophy", "hierarchy", "execution", "specificity", "restraint", "accessibility", "responsive_behavior", "repairs"]) {
-        assertPhase(phase, key in critique, `prototype critique missing ${key}`);
-    }
+    const template = recordField(artifactRecord(runtime, "prototype_evidence", phase), "template", phase);
+    assertPhase(phase, "prompt_pack_type" in template, "prototype template missing prompt pack type");
+    assertPhase(phase, "validation_input" in template, "prototype template missing validation input");
+    assertPhase(phase, "internal_pipeline" in template, "prototype template missing internal pipeline");
+    assertPhase(phase, "preflight_quality_gate" in template, "prototype template missing preflight quality gate");
+    assertPhase(phase, "direction_count_policy" in template, "prototype template missing direction count policy");
+    assertPhase(phase, "normalized_input" in template, "prototype template missing normalized input");
+    assertPhase(phase, "strategic_core" in template, "prototype template missing strategic core");
+    assertPhase(phase, "product_experience_model" in template, "prototype template missing product experience model");
+    assertPhase(phase, "prototype_reality_gate" in template, "prototype template missing prototype reality gate");
+    assertPhase(phase, "directions" in template, "prototype template missing directions");
+    assertPhase(phase, "build_recommendation" in template, "prototype template missing build recommendation");
+    assertPhase(phase, "prompt_text_manifest" in template, "prototype template missing prompt text manifest");
+    assertPhase(phase, "post_validate" in template, "prototype template missing post-validate gate");
+    assertPhase(phase, "image_generation" in template, "prototype template missing image generation state");
+    assertPhase(phase, "negative_constraints" in template, "prototype template missing negative constraints");
+    assertPhase(phase, "review_plan" in template, "prototype template missing review plan");
+    const validationInput = recordField(template, "validation_input", phase);
+    assertPhase(phase, !String(validationInput.mode).includes("vision_only"), "prototype template still allows vision_only validation input");
+    const directionPolicy = recordField(template, "direction_count_policy", phase);
+    assertPhase(phase, directionPolicy.resolved_count === 3, "prototype template should default delegated direction count to 3");
+    assertPhase(phase, String(directionPolicy.ask_user_question).includes("strategically different prototype directions"), "prototype template missing direction count askUserQuestion");
     const handoff = recordField(template, "handoff", phase);
     assertPhase(phase, handoff.next_command !== "/ow:decision", "prototype template exposes manual decision as next command");
     assertListIncludes(phase, USER_FACING_DISCOVERY_HANDOFFS, String(handoff.next_command), "prototype template next command is not user-facing");
 }
+async function verifyInternalProtoPipelinePhase(runtime) {
+    const phase = "internal-proto-pipeline";
+    const buildProtoPrompt = command("build-proto-prompt", phase);
+    const vision2Prompt = command("vision2prompt", phase);
+    const prompt2Proto = command("prompt2proto", phase);
+    assertPhase(phase, buildProtoPrompt.visibility === "internal", "source build-proto-prompt command is not internal");
+    assertPhase(phase, vision2Prompt.visibility === "internal", "source vision2prompt command is not internal");
+    assertPhase(phase, prompt2Proto.visibility === "internal", "source prompt2proto command is not internal");
+    assertPhase(phase, protocolFor(buildProtoPrompt, phase).interactionMode === "internal-build-proto-prompt-pack-compiler", "build-proto-prompt source protocol mismatch");
+    assertPhase(phase, protocolFor(vision2Prompt, phase).interactionMode === "internal-vision-to-strategic-prompt-text", "vision2prompt source protocol mismatch");
+    assertPhase(phase, protocolFor(prompt2Proto, phase).interactionMode === "internal-prompt-text-to-prototype-images", "prompt2proto source protocol mismatch");
+    const generatedBuildProtoPrompt = commandRecord(runtime, "build-proto-prompt", phase);
+    const generatedVision2Prompt = commandRecord(runtime, "vision2prompt", phase);
+    const generatedPrompt2Proto = commandRecord(runtime, "prompt2proto", phase);
+    assertPhase(phase, stringField(generatedBuildProtoPrompt, "visibility", phase) === "internal", "generated build-proto-prompt command is not internal");
+    assertPhase(phase, stringField(generatedVision2Prompt, "visibility", phase) === "internal", "generated vision2prompt command is not internal");
+    assertPhase(phase, stringField(generatedPrompt2Proto, "visibility", phase) === "internal", "generated prompt2proto command is not internal");
+    const protoHandoffs = stringList(commandRecord(runtime, "proto", phase), "handoff_commands", phase);
+    assertListExcludes(phase, protoHandoffs, "/ow:vision2prompt", "proto exposes vision2prompt as user handoff");
+    assertListExcludes(phase, protoHandoffs, "/ow:prompt2proto", "proto exposes prompt2proto as user handoff");
+    const buildProtoPromptSkill = await readSkill(runtime, "ow-build-proto-prompt");
+    const vision2PromptSkill = await readSkill(runtime, "ow-vision2prompt");
+    const prompt2ProtoSkill = await readSkill(runtime, "ow-prompt2proto");
+    assertIncludes(phase, buildProtoPromptSkill, "<command_visibility>internal</command_visibility>", "build-proto-prompt skill is not internal");
+    assertIncludes(phase, buildProtoPromptSkill, "internal-build-proto-prompt-pack-compiler", "build-proto-prompt skill missing compiler mode");
+    assertIncludes(phase, buildProtoPromptSkill, "Do not generate images", "build-proto-prompt skill missing image boundary");
+    assertIncludes(phase, vision2PromptSkill, "<command_visibility>internal</command_visibility>", "vision2prompt skill is not internal");
+    assertIncludes(phase, vision2PromptSkill, "ready_for_image_generation", "vision2prompt skill missing prompt readiness output");
+    assertIncludes(phase, vision2PromptSkill, "product_experience_model", "vision2prompt skill missing product experience model output");
+    assertIncludes(phase, vision2PromptSkill, "anti_generic_constraints", "vision2prompt skill missing anti-generic constraints output");
+    assertIncludes(phase, vision2PromptSkill, "post_validate.status: pass", "vision2prompt skill missing post_validate pass requirement");
+    assertIncludes(phase, vision2PromptSkill, "post_validate.status: skipped", "vision2prompt skill missing single-direction skip requirement");
+    assertIncludes(phase, vision2PromptSkill, "post_validate.status: fail", "vision2prompt skill missing post_validate failure repair route");
+    assertIncludes(phase, prompt2ProtoSkill, "<command_visibility>internal</command_visibility>", "prompt2proto skill is not internal");
+    assertIncludes(phase, prompt2ProtoSkill, "post_validate.status pass or skipped", "prompt2proto skill missing post_validate readiness gate");
+    assertIncludes(phase, prompt2ProtoSkill, "Every generated image must record image_id", "prompt2proto skill missing image metadata contract");
+}
 async function verifyTunePhase(runtime) {
     const phase = "tune";
     const source = command("tune", phase);
     const protocol = protocolFor(source, phase);
-    assertPhase(phase, protocol.interactionMode === "prototype-revision-orchestration", "tune source protocol is not revision orchestration");
+    assertPhase(phase, protocol.interactionMode === "screen-bound-prototype-refinement", "tune source protocol is not screen-bound refinement");
     assertDiscoveryHandoffs(phase, protocol.handoffCommands, "source tune handoffs");
     assertListIncludes(phase, protocol.allowedOutputs, ".openworkflow/decisions/<id>/DECISION.yaml", "tune cannot write decision audit");
     assertListExcludes(phase, protocol.requiredContext, ".openworkflow/prototypes/PROTOTYPE_INDEX.yaml", "tune requires prototype index and cannot bootstrap from validation");
     assertListIncludes(phase, protocol.optionalContext, ".openworkflow/prototypes/PROTOTYPE_INDEX.yaml", "tune optional context missing prototype index");
-    assertSomeIncludes(phase, protocol.auditCheckpoints.before, "/ow:tune:proto default to the current prototype", "tune does not default to current prototype");
-    assertSomeIncludes(phase, protocol.auditCheckpoints.before, "no current prototype exists", "tune does not orchestrate proto when prototype is absent");
+    assertSomeIncludes(phase, protocol.auditCheckpoints.before, "latest approved", "tune does not resolve latest baseline");
+    assertSomeIncludes(phase, protocol.auditCheckpoints.before, "Normalize tune inputs", "tune does not normalize inputs before audit");
+    assertSomeIncludes(phase, protocol.auditCheckpoints.before, "baseline_resolution", "tune does not record baseline resolution");
+    assertSomeIncludes(phase, protocol.auditCheckpoints.during, "Carry forward locked screens", "tune does not carry forward locked elements");
+    assertSomeIncludes(phase, protocol.auditCheckpoints.before, "Assign stable source screen ids", "tune does not assign stable source ids");
+    assertSomeIncludes(phase, protocol.auditCheckpoints.during, "Interpret the tune request", "tune does not interpret tune request modes");
+    assertSomeIncludes(phase, protocol.auditCheckpoints.during, "Detect conflicts", "tune does not detect tune conflicts");
+    assertSomeIncludes(phase, protocol.auditCheckpoints.during, "MUST_INHERIT", "tune does not require delta rules");
+    assertSomeIncludes(phase, protocol.auditCheckpoints.during, "screen_delta_matrix", "tune does not require screen delta matrix");
+    assertSomeIncludes(phase, protocol.auditCheckpoints.during, "target screen id", "tune does not bind screen prompts");
+    assertSomeIncludes(phase, protocol.auditCheckpoints.during, "generation_order", "tune does not require generation order");
     assertSomeIncludes(phase, protocol.auditCheckpoints.after, "internal decision audit record", "tune does not record decision audit internally");
     assertSomeIncludes(phase, protocol.antiPatterns, "Do not ask the user to manually invoke /ow:decision", "tune permits manual decision handoff");
     const generated = commandRecord(runtime, "tune", phase);
@@ -170,10 +336,31 @@ async function verifyTunePhase(runtime) {
     assertListExcludes(phase, stringList(packet, "required", phase), ".openworkflow/prototypes/PROTOTYPE_INDEX.yaml", "context packet requires prototype index");
     assertListIncludes(phase, stringList(packet, "optional", phase), ".openworkflow/prototypes/PROTOTYPE_INDEX.yaml", "context packet optional context missing prototype index");
     const skill = await readSkill(runtime, "ow-tune");
-    for (const tag of ["target_resolution", "proto_orchestration", "revision_protocol", "internal_decision_audit"]) {
+    for (const tag of [
+        "target_resolution",
+        "multi_round_baseline_inheritance",
+        "input_normalization",
+        "baseline_screen_audit",
+        "product_system_extraction",
+        "tune_request_interpretation",
+        "inheritance_delta_rules",
+        "screen_manifest",
+        "refined_prompt_pack_output",
+        "internal_decision_audit",
+    ]) {
         assertIncludes(phase, skill, `<${tag}>`, `skill missing ${tag} block`);
     }
-    assertIncludes(phase, skill, "/ow:tune resolves to the current prototype by default.", "skill lost default target behavior");
+    assertIncludes(phase, skill, "/ow:tune resolves to the latest approved prototype prompt pack", "skill lost default target behavior");
+    assertIncludes(phase, skill, "<multi_round_baseline_inheritance>", "skill lost multi-round inheritance block");
+    assertIncludes(phase, skill, "baseline_resolution with latest_approved_baseline_group_id", "skill lost baseline resolution rule");
+    assertIncludes(phase, skill, "carry_forward with locked_screens", "skill lost carry-forward rule");
+    assertIncludes(phase, skill, "Never silently regenerate from stale source screens", "skill permits stale source fallback");
+    assertIncludes(phase, skill, "Normalize baseline_source_type", "skill lost input normalization rule");
+    assertIncludes(phase, skill, "Extract product thesis", "skill lost product system extraction rule");
+    assertIncludes(phase, skill, "Classify the request", "skill lost tune request interpretation rule");
+    assertIncludes(phase, skill, "screen_delta_matrix rows", "skill lost screen delta matrix rule");
+    assertIncludes(phase, skill, "Every screen prompt must include prompt_id", "skill lost screen manifest rule");
+    assertIncludes(phase, skill, "Generation Order, and Acceptance Checklist", "skill lost refined prompt pack output structure");
     assertIncludes(phase, skill, "Every tune pass must write or update a decision audit record internally.", "skill lost decision audit requirement");
     assertIncludes(phase, skill, "Do not expose /ow:decision as the next manual user step", "skill exposes decision as user step");
     assertNotIncludes(phase, extractBlock(skill, "handoff_commands"), "/ow:decision", "skill exposes decision in tune handoffs");
@@ -196,9 +383,90 @@ async function verifyInternalDecisionPhase(runtime) {
     assertIncludes(phase, skill, "<internal_audit_only>", "decision skill missing internal audit block");
     assertIncludes(phase, skill, "not as a normal user-facing workflow step", "decision skill exposes normal user workflow");
 }
+async function verifyProductionCommandPhases(runtime) {
+    await verifySpecPhase(runtime);
+    await verifyChangePhase(runtime);
+    await verifyTeamPhase(runtime);
+}
+async function verifySpecPhase(runtime) {
+    const phase = "spec";
+    const source = command("spec", phase);
+    const protocol = protocolFor(source, phase);
+    assertPhase(phase, protocol.interactionMode === "accepted-design-to-production-spec", "spec source protocol is not production spec");
+    assertListIncludes(phase, protocol.requiredContext, ".openworkflow/design/DESIGN_INDEX.yaml", "spec does not require design index");
+    assertListIncludes(phase, protocol.allowedOutputs, ".openworkflow/specs/<id>/SPEC.yaml", "spec cannot write SPEC.yaml");
+    assertListIncludes(phase, protocol.forbiddenOutputs, ".openworkflow/changes/**", "spec can create changes");
+    assertExactList(phase, protocol.handoffCommands, ["/ow:change", "/ow:design"], "spec source handoffs changed");
+    assertSomeIncludes(phase, protocol.auditCheckpoints.before, "Lazy-create", "spec missing lazy-create checkpoint");
+    const generated = commandRecord(runtime, "spec", phase);
+    assertPhase(phase, stringField(generated, "depth", phase) === "deep", "generated spec is not deep");
+    assertListIncludes(phase, stringList(generated, "allowed_outputs", phase), ".openworkflow/specs/<id>/SPEC.yaml", "generated spec cannot write SPEC.yaml");
+    const packet = packetRecord(runtime, "/ow:spec", phase);
+    assertListIncludes(phase, stringList(packet, "required", phase), ".openworkflow/design/DESIGN_INDEX.yaml", "spec packet does not require design index");
+    assertSomeIncludes(phase, nestedStringList(packet, ["audit_checkpoints", "before"], phase), "Lazy-create", "spec packet lost lazy-create checkpoint");
+    const skill = await readSkill(runtime, "ow-spec");
+    for (const required of ["<lazy_create>", "<spec_quality_bar>", "<readiness_gate>", "A production spec must be enough for an implementation agent"]) {
+        assertIncludes(phase, skill, required, `spec skill missing ${required}`);
+    }
+    const artifact = artifactRecord(runtime, "production_spec", phase);
+    assertPhase(phase, artifact.command === "/ow:spec", "production_spec command mismatch");
+    assertPhase(phase, artifact.lazy_create === true, "production_spec is not marked lazy_create");
+    assertPhase(phase, "summary_policy" in artifact, "production_spec missing summary policy");
+    const template = recordField(artifact, "template", phase);
+    assertPhase(phase, "change_readiness" in template, "production_spec template missing change_readiness");
+}
+async function verifyChangePhase(runtime) {
+    const phase = "change";
+    const source = command("change", phase);
+    const protocol = protocolFor(source, phase);
+    assertPhase(phase, protocol.interactionMode === "production-change-planning", "change source protocol is not production planning");
+    assertListIncludes(phase, protocol.requiredContext, ".openworkflow/specs/SPEC_INDEX.yaml", "change does not require spec index");
+    assertListIncludes(phase, protocol.allowedOutputs, ".openworkflow/changes/<id>/WORK_ITEMS.yaml", "change cannot write work items");
+    assertListIncludes(phase, protocol.forbiddenOutputs, ".openworkflow/runtime/**", "change can create runtime");
+    assertExactList(phase, protocol.handoffCommands, ["/ow:team", "/ow:spec"], "change source handoffs changed");
+    const generated = commandRecord(runtime, "change", phase);
+    assertPhase(phase, stringField(generated, "depth", phase) === "deep", "generated change is not deep");
+    const packet = packetRecord(runtime, "/ow:change", phase);
+    assertListIncludes(phase, stringList(packet, "required", phase), ".openworkflow/specs/SPEC_INDEX.yaml", "change packet does not require spec index");
+    assertSomeIncludes(phase, nestedStringList(packet, ["audit_checkpoints", "during"], phase), "owned paths", "change packet lost work-item planning guidance");
+    const skill = await readSkill(runtime, "ow-change");
+    for (const required of ["<lazy_create>", "<planning_quality_bar>", "<readiness_gate>", "owned_paths"]) {
+        assertIncludes(phase, skill, required, `change skill missing ${required}`);
+    }
+    const artifact = artifactRecord(runtime, "production_change", phase);
+    assertPhase(phase, artifact.command === "/ow:change", "production_change command mismatch");
+    assertPhase(phase, artifact.lazy_create === true, "production_change is not marked lazy_create");
+    assertPhase(phase, "summary_policy" in artifact, "production_change missing summary policy");
+    const template = recordField(artifact, "template", phase);
+    assertPhase(phase, "runtime_readiness" in template, "production_change template missing runtime_readiness");
+}
+async function verifyTeamPhase(runtime) {
+    const phase = "team";
+    const source = command("team", phase);
+    const protocol = protocolFor(source, phase);
+    assertPhase(phase, protocol.interactionMode === "approved-change-team-execution", "team source protocol is not approved execution");
+    assertListIncludes(phase, protocol.requiredContext, ".openworkflow/changes/CHANGE_INDEX.yaml", "team does not require change index");
+    assertListIncludes(phase, protocol.allowedOutputs, ".openworkflow/runtime/<id>/STATE.yaml", "team cannot write runtime state");
+    assertExactList(phase, protocol.handoffCommands, ["/ow:change"], "team source handoffs changed");
+    const generated = commandRecord(runtime, "team", phase);
+    assertPhase(phase, stringField(generated, "depth", phase) === "deep", "generated team is not deep");
+    const packet = packetRecord(runtime, "/ow:team", phase);
+    assertListIncludes(phase, stringList(packet, "required", phase), ".openworkflow/changes/CHANGE_INDEX.yaml", "team packet does not require change index");
+    assertSomeIncludes(phase, nestedStringList(packet, ["audit_checkpoints", "before"], phase), "Lazy-create runtime state", "team packet lost lazy-create checkpoint");
+    const skill = await readSkill(runtime, "ow-team");
+    for (const required of ["<lazy_create>", "<execution_quality_bar>", "<handoff_gate>", "Track active change, active work item"]) {
+        assertIncludes(phase, skill, required, `team skill missing ${required}`);
+    }
+    const artifact = artifactRecord(runtime, "team_runtime", phase);
+    assertPhase(phase, artifact.command === "/ow:team", "team_runtime command mismatch");
+    assertPhase(phase, artifact.lazy_create === true, "team_runtime is not marked lazy_create");
+    assertPhase(phase, "summary_policy" in artifact, "team_runtime missing summary policy");
+    const template = recordField(artifact, "template", phase);
+    assertPhase(phase, "handoff" in template, "team_runtime template missing handoff");
+}
 async function verifyDisplayLabels(runtime) {
     const phase = "display-labels";
-    for (const id of ["vision", "validation", "proto", "tune", "decision", "design", "spec"]) {
+    for (const id of ["vision", "validation", "proto", "tune", "decision", "design", "spec", "change", "team"]) {
         const skillName = `ow-${id}`;
         const semanticCommand = `/ow:${id}`;
         const displayName = `ow:${id}`;
@@ -210,6 +478,142 @@ async function verifyDisplayLabels(runtime) {
         assertIncludes(phase, interfaceContent, `Use ${semanticCommand}`, `${skillName} default prompt lost semantic command`);
     }
 }
+async function verifyBriefReadModel(runtime) {
+    const phase = "brief-read-model";
+    const report = JSON.parse(await runCapture(["node", CLI, "brief", "--root", runtime.target, "--json"], { ...process.env }));
+    assertPhase(phase, report.command === "brief", "brief report command mismatch");
+    assertPhase(phase, report.ok === true, "brief report should be ok");
+    const json = recordField(report, "data", phase);
+    for (const key of ["project", "workflow", "read_this_first", "active_pointers", "health", "git", "agent_guidance"]) {
+        assertPhase(phase, key in json, `brief missing key ${key}`);
+    }
+    const workflow = recordField(json, "workflow", phase);
+    assertPhase(phase, workflow.active_stage === "workflow", "brief active_stage mismatch");
+    assertPhase(phase, workflow.next_command === "/ow:vision", "brief next_command mismatch");
+    const readThisFirst = json.read_this_first;
+    assertPhase(phase, Array.isArray(readThisFirst), "brief read_this_first must be a list");
+    assertPhase(phase, readThisFirst.includes(".openworkflow/CURRENT_STATE.yaml"), "brief does not include current state read pointer");
+    const guidance = recordField(json, "agent_guidance", phase);
+    assertPhase(phase, String(guidance.recommended_next_action).includes("/ow:vision"), "brief guidance does not point to next command");
+}
+async function verifyCommandReadiness(runtime) {
+    const phase = "command-readiness";
+    const report = JSON.parse(await runCapture(["node", CLI, "check", "/ow:vision", "--root", runtime.target, "--json"], { ...process.env }));
+    assertPhase(phase, report.command === "check", "check report command mismatch");
+    assertPhase(phase, report.ok === true, "vision check should be ok");
+    const data = recordField(report, "data", phase);
+    assertPhase(phase, data.ready === true, "vision should be ready");
+    assertPhase(phase, Array.isArray(data.required_context), "check missing required_context");
+    assertPhase(phase, Array.isArray(data.forbidden_context), "check missing forbidden_context");
+    assertPhase(phase, Array.isArray(data.allowed_outputs), "check missing allowed_outputs");
+    assertPhase(phase, Array.isArray(data.handoff_commands), "check missing handoff_commands");
+    const spec = await runCaptureStatus(["node", CLI, "check", "ow-spec", "--root", runtime.target, "--json"], { ...process.env });
+    assertPhase(phase, spec.code !== 0, "spec check should fail without product design");
+    const specReport = JSON.parse(spec.output);
+    const specData = recordField(specReport, "data", phase);
+    assertPhase(phase, Array.isArray(specData.blockers), "spec check missing blockers");
+}
+async function verifySummaryReadModel(runtime) {
+    const phase = "summary-read-model";
+    const report = JSON.parse(await runCapture(["node", CLI, "summaries", "--root", runtime.target, "--json"], { ...process.env }));
+    assertPhase(phase, report.command === "summaries", "summaries report command mismatch");
+    assertPhase(phase, report.ok === true, "fresh summaries report should be ok");
+    const data = recordField(report, "data", phase);
+    const counts = recordField(data, "counts", phase);
+    assertPhase(phase, Number(counts.not_instantiated) > 0, "fresh summaries should report not_instantiated artifacts");
+    assertPhase(phase, Array.isArray(data.entries), "summaries missing entries");
+    const brief = JSON.parse(await runCapture(["node", CLI, "brief", "--root", runtime.target, "--json"], { ...process.env }));
+    const briefData = recordField(brief, "data", phase);
+    const health = recordField(briefData, "health", phase);
+    assertPhase(phase, "summaries" in health, "brief health missing summaries");
+    const check = JSON.parse(await runCapture(["node", CLI, "check", "/ow:vision", "--root", runtime.target, "--json"], { ...process.env }));
+    const checkData = recordField(check, "data", phase);
+    assertPhase(phase, Array.isArray(checkData.summary_guidance), "check missing summary_guidance");
+    const inspect = JSON.parse(await runCapture(["node", CLI, "inspect", "--root", runtime.target, "--json"], { ...process.env }));
+    assertPhase(phase, inspect.command === "inspect", "inspect report command mismatch");
+    assertPhase(phase, inspect.ok === true, "fresh inspect report should be ok");
+    const inspectData = recordField(inspect, "data", phase);
+    for (const key of ["project", "workflow", "health", "summaries", "next_command_check", "read_order", "recommended_next_actions"]) {
+        assertPhase(phase, key in inspectData, `inspect missing key ${key}`);
+    }
+    const readOrder = recordField(inspectData, "read_order", phase);
+    assertPhase(phase, Array.isArray(readOrder.must_read), "inspect read_order missing must_read");
+    assertPhase(phase, readOrder.must_read.includes(".openworkflow/CURRENT_STATE.yaml"), "inspect must_read missing current state");
+    const context = JSON.parse(await runCapture(["node", CLI, "context", "--root", runtime.target, "--json"], { ...process.env }));
+    assertPhase(phase, context.command === "context", "context report command mismatch");
+    assertPhase(phase, context.ok === true, "fresh context report should be ok");
+    const contextData = recordField(context, "data", phase);
+    for (const key of ["normalized_command", "packet_id", "budget", "readiness", "inspect", "context_packet", "included", "omitted", "recommended_next_actions"]) {
+        assertPhase(phase, key in contextData, `context missing key ${key}`);
+    }
+    assertPhase(phase, contextData.normalized_command === "/ow:vision", "context should default to CURRENT_STATE.next_command");
+    assertPhase(phase, contextData.packet_id === "context:vision", "context missing packet id");
+    assertPhase(phase, Array.isArray(contextData.included), "context included must be array");
+    assertPhase(phase, Array.isArray(contextData.omitted), "context omitted must be array");
+}
+async function runCaptureStatus(command, env) {
+    return new Promise((resolvePromise, reject) => {
+        let output = "";
+        const child = spawn(command[0] ?? "", command.slice(1), {
+            cwd: REPO_ROOT,
+            env,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        child.stdout.on("data", (chunk) => {
+            output += chunk.toString("utf8");
+        });
+        child.stderr.on("data", (chunk) => {
+            output += chunk.toString("utf8");
+        });
+        child.on("error", reject);
+        child.on("close", (code) => {
+            resolvePromise({ code, output });
+        });
+    });
+}
+async function verifyAgentOnboarding(target, env) {
+    const phase = "agent-onboarding";
+    const guide = await read(join(target, "AGENTS.md"));
+    assertIncludes(phase, guide, "openworkflow --help", "AGENTS.md does not point agents to CLI help");
+    assertIncludes(phase, guide, "Prefer `--json`", "AGENTS.md does not mention JSON report mode");
+    assertIncludes(phase, guide, "openworkflow inspect --root . --json", "AGENTS.md does not mention inspect command");
+    assertIncludes(phase, guide, "openworkflow context --root . --json", "AGENTS.md does not mention context command");
+    assertIncludes(phase, guide, "command_audit", "AGENTS.md does not mention compact command audit slice");
+    assertIncludes(phase, guide, "--max-bytes <n>", "AGENTS.md does not mention context budget");
+    assertIncludes(phase, guide, "--mode full", "AGENTS.md does not mention full context mode");
+    assertIncludes(phase, guide, "openworkflow draft --root . --artifact <type> --id <id> --json", "AGENTS.md does not mention draft command");
+    assertIncludes(phase, guide, "openworkflow register --root . --artifact <path> --json", "AGENTS.md does not mention register command");
+    assertIncludes(phase, guide, ".openworkflow/CURRENT_STATE.yaml", "AGENTS.md does not point agents to current state");
+    assertIncludes(phase, guide, "CLI commands maintain and summarize the repo-local workflow surface", "AGENTS.md does not distinguish CLI maintenance commands");
+    assertIncludes(phase, guide, "openworkflow brief --root .", "AGENTS.md does not mention brief command");
+    assertIncludes(phase, guide, "openworkflow status --root .", "AGENTS.md does not mention status command");
+    assertIncludes(phase, guide, "openworkflow check /ow:<command> --root . --json", "AGENTS.md does not mention check command");
+    assertIncludes(phase, guide, "openworkflow summaries --root . --json", "AGENTS.md does not mention summaries command");
+    assertIncludes(phase, guide, "openworkflow summarize --root . --artifact <path> --json", "AGENTS.md does not mention summarize command");
+    assertIncludes(phase, guide, "SUMMARY.yaml trust is checked by `summaries`, not by `validate`", "AGENTS.md does not explain validate/summaries boundary");
+    assertIncludes(phase, guide, "Repo-local workflow commands are delivered as Agent skills", "AGENTS.md does not distinguish workflow skill commands");
+    assertIncludes(phase, guide, "Respect lazy creation", "AGENTS.md does not preserve lazy artifact creation boundary");
+    const help = await runCapture(["node", CLI, "--help"], env);
+    assertIncludes(phase, help, "Agent quick start", "help missing Agent quick start");
+    assertIncludes(phase, help, "Two command surfaces", "help missing command surface distinction");
+    assertIncludes(phase, help, "Repo-local workflow commands are Agent skills", "help missing workflow skill explanation");
+    assertIncludes(phase, help, "Lazy creation boundary", "help missing lazy creation boundary");
+    assertIncludes(phase, help, "Every command supports --json", "help missing JSON report mode");
+    assertIncludes(phase, help, "inspect", "help missing inspect command");
+    assertIncludes(phase, help, "context", "help missing context command");
+    assertIncludes(phase, help, "command_audit", "help missing compact command audit slice");
+    assertIncludes(phase, help, "--max-bytes", "help missing context budget");
+    assertIncludes(phase, help, "--mode full", "help missing full context mode");
+    assertIncludes(phase, help, "draft", "help missing draft command");
+    assertIncludes(phase, help, "contract-shaped source artifact", "help missing draft boundary");
+    assertIncludes(phase, help, "register", "help missing register command");
+    assertIncludes(phase, help, "index registration", "help missing register boundary");
+    assertIncludes(phase, help, "check", "help missing check command");
+    assertIncludes(phase, help, "summaries", "help missing summaries command");
+    assertIncludes(phase, help, "summarize", "help missing summarize command");
+    assertIncludes(phase, help, "pass --write to update summary files", "help missing summarize write boundary");
+    assertIncludes(phase, help, "SUMMARY.yaml freshness is checked by summaries", "help missing validate/summaries boundary");
+}
 async function run(command, env) {
     await new Promise((resolvePromise, reject) => {
         const child = spawn(command[0] ?? "", command.slice(1), {
@@ -228,6 +632,31 @@ async function run(command, env) {
         });
     });
 }
+async function runCapture(command, env) {
+    return new Promise((resolvePromise, reject) => {
+        let output = "";
+        const child = spawn(command[0] ?? "", command.slice(1), {
+            cwd: REPO_ROOT,
+            env,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        child.stdout.on("data", (chunk) => {
+            output += chunk.toString("utf8");
+        });
+        child.stderr.on("data", (chunk) => {
+            output += chunk.toString("utf8");
+        });
+        child.on("error", reject);
+        child.on("close", (code) => {
+            if (code === 0) {
+                resolvePromise(output);
+            }
+            else {
+                reject(new Error(`command failed (${code ?? "signal"}): ${command.join(" ")}\n${output}`));
+            }
+        });
+    });
+}
 function command(id, phase) {
     const found = getWorkflowCommands().find((item) => item.id === id);
     if (!found) {
@@ -247,6 +676,9 @@ function commandRecord(runtime, id, phase) {
 function packetRecord(runtime, command, phase) {
     return findRecord(runtime.packets, "command", command, phase, `context packet missing ${command}`);
 }
+function artifactRecord(runtime, artifactType, phase) {
+    return findRecord(runtime.artifacts, "artifact_type", artifactType, phase, `artifact contract missing ${artifactType}`);
+}
 function findRecord(records, key, value, phase, message) {
     const found = records.find((record) => record[key] === value);
     if (!found) {